// ----------------------------------------------------------------------------
// ----------------------------------------------------------------------------
// ----------------------------------------------------------------------------
void starsim( Int_t nevents=1, Int_t rngSeed=1234 )
{
gROOT->ProcessLine(".L bfc.C");
{
TString simple = "y2012 geant gstar usexgeom agml ";
bfc(0, simple );
}
gSystem->Load( "libVMC.so");
gSystem->Load( "StarGeneratorUtil.so" );
gSystem->Load( "StarGeneratorEvent.so" );
gSystem->Load( "StarGeneratorBase.so" );
gSystem->Load( "libMathMore.so" );
gSystem->Load( "xgeometry.so" );
// Setup RNG seed and captuire ROOT TRandom
StarRandom::seed(rngSeed);
StarRandom::capture();
//
// Create the primary event generator and insert it
// before the geant maker
//
// StarPrimaryMaker *
primary = new StarPrimaryMaker();
{
primary -> SetFileName( "Herwig6.starsim.root");
chain -> AddBefore( "geant", primary );
}
//
// Setup an event generator
//
Herwig6( "pp" );
//
// Initialize primary event generator and all sub makers
//
primary -> Init();
//
// Setup geometry and set starsim to use agusread for input
//
geometry("y2012");
command("gkine -4 0");
command("gfile o herwig6.starsim.fzd");
//
// Trigger on nevents
//
trig( nevents );
command("call agexit"); // Make sure that STARSIM exits properly
}
void lMuDst() {
gROOT->LoadMacro("bfc.C");
TString Chain("StEvent,CMuDst,nodefault");
bfc(-2,Chain,0,0,0);
// gROOT->LoadMacro("FitP_t.h+");
gSystem->Load("libEG");
// gSystem->Load("libStKFVertex");
}
/*!
Converts 32 bit value in register \a reg to 16 bit value.
*/
inline void NesCpuTranslator::mTo16Bit(Register reg)
{
#if defined(CAN_USE_ARMV7_INSTRUCTIONS)
__ bfc(reg, 16, 16);
#else
__ mov(reg, Operand(reg, LSL, 16));
__ mov(reg, Operand(reg, LSR, 16));
#endif
}
void runBfc(const Char_t *file="data/st_fms_16077027_raw_1000002.daq", Int_t nevents=1000000){
gROOT->LoadMacro("bfc.C"); // Load big "full" chain
bfc(-1,opt,file); // Setup but do not init
// Intializet the chain
chain->Init();
// Process events
chain->EventLoop(nevents);
}
void bfcFms(int nevents = 1000,
const char* fzfile = "test.fzd",
const char* chainopt = "DbV20110923 tpcRS y2011 fmsDb MakeEvent ITTF NoSsdIt NoSvtIt Idst BAna l0 Tree logger Sti VFPPVnoCTB beamLine tpcDB TpcHitMover TpxClu bbcSim btofsim tags emcY2 EEfs evout -dstout IdTruth geantout big fzin MiniMcMk clearmem sdt20110417.193427")
{
gROOT->LoadMacro("bfc.C");
bfc(-1,chainopt,fzfile);
gSystem->Load("StFmsSimulatorMaker");
StFmsSimulatorMaker* fmsSim = new StFmsSimulatorMaker;
chain->AddAfter("fmsDb",fmsSim);
chain->Init();
chain->EventLoop(nevents);
}
void xtrak(int flag=0)
{
gROOT->LoadMacro("./bfc.C");
TString opt,fil;
int fr=1,to=1;
int ierr = 0;
int KNN = 0;
#if 1 //Same but Sti
opt = "in,y2016,AgML,usexgeom,FieldOn,MakeEvent,Sti,NoSsdIt,NoSvtIt,";
opt+= "Idst,BAna,l0,Tree,logger,genvtx,tpcDB,bbcSim,btofsim,mtdSim,tags,emcY2,EEfs,evout,";
opt+= "-dstout,IdTruth,big,MiniMcMk";
fil = "/star/simu/simu/perev/bug/data/rcf15001_0_100evts.event.root";
#endif
//////////////////////////////////////////////////////////////////////////////
bfc(-1,opt,fil);
//chain->SetAttr("seedFinders","KN","Stv");
// chain->SetAttr(".call","SetDebug(1)","St_db_Maker::");
//chain->SetAttr("makePulls",1,"StiMaker::");
// bfc(fr,to,opt,fil);
//int ixt = gSystem->Load("StvUtil");
gSystem->Load("StXTrakMaker");
chain->AddAfter("Sti", new StXTrakMaker );
chain->AddAfter("StXTrak", new StXTrakTestMaker);
StMaker::lsMakers(chain);
int stv = opt.Contains("Stv");
if (stv) { StvDebug::SetDebug(11);}
else { StiDebug::SetDebug(11);}
#if 1
int sim =0;
if (fil.Contains(".fz")) sim = 1;
if (!sim) {
rmMaker(chain,"geant");
} else {
gSystem->Setenv("STARFPE","NO");
}
#endif
chain->Init();
if (KNN) chain->SetAttr("seedFinders","kn","Stv");
chain->EventLoop(30);
chain->Finish();
}
void runSimBfc( Int_t nEvents=100, Int_t run=100, const char* pid="gamma", int merge=1,
int print=0,
TString myDir=input_dir, TString myOutDir=output_dir,
TString myChain=input_chain, Int_t mnEvents=1){
gROOT->LoadMacro("bfc.C");
gROOT->Macro("loadMuDst.C");
TString myDat=Form("test_%s_run%i.fzd",pid,run);
bfc( -1, myChain, myDir+myDat );
TString outfile = myOutDir + myDat.ReplaceAll(".fzd",".root");
//TString outfile = myOutDir + chain->GetFileOut();
cout << "output file=" <<outfile<<endl;
chain->SetOutputFile(outfile);
StFmsDbMaker* fmsdb = (StFmsDbMaker*) chain->GetMaker("fmsDb");
//fmsdb->readGainFromText();
//fmsdb->forceUniformGain(0.038);
//fmsdb->forceUniformGainCorrection(1.0);
fmsdb->setDebug(2);
fmsdb->readRecParamFromFile();
StFmsFastSimulatorMaker *fmssim = (StFmsFastSimulatorMaker*) chain->GetMaker("fmsSim");
fmssim->SetDebug();
fmssim->setFpsNPhotonPerMIP(100.0);
StFmsPointMaker* pointMaker = (StFmsPointMaker*) chain->GetMaker("StFmsPointMaker");
pointMaker->setMergeSmallToLarge(merge);
gSystem->Load("StFmsFpsMaker");
StFmsFpsMaker* fmsfps = new StFmsFpsMaker();
fmsfps->setPrint(4);
outfile.ReplaceAll(".root",".fmsfps.root");
fmsfps->setQA(outfile.Data());
if(print>=9){
gSystem->Load("StFmsEventDisplay");
StFmsEventDisplay* fmsed = new StFmsEventDisplay();
fmsed->setMaxEvents(100);
//outfile.ReplaceAll(".fmsfps.root",".eventDisplay.pdf");
outfile.ReplaceAll(".fmsfps.root",".eventDisplay.png");
fmsed->setFileName(outfile.Data());
if(print==10) fmsed->setFilter(1);
}
chain->Init();
StMaker::lsMakers(chain);
chain->EventLoop(mnEvents,nEvents);
chain->Finish();
}
int main(int argc, char **argv){
if(argc != 2){
puts("bfc.exe");
puts(" usage: bfc.exe <*.bf>");
return 0;
}
const char *ifn = argv[1];
char ofn[_MAX_PATH];
// 出力ファイル名生成
strcpy(ofn, ifn);
int len = strlen(ofn);
if(len >= 4 && strcmp(ofn+len-3, ".bf") == 0){
strcpy(ofn+len-3, ".exe");
} else {
strcat(ofn, ".exe");
}
return bfc(ifn, ofn);
}
//________________________________________________________________________________
void MakeSvtOnGlobal(){
gROOT->LoadMacro("bfc.C");
bfc(0,"mysql,tpcDb,MagF,nodefault");
StMaker *db = chain->Maker("db");
if (! db) return;
db->SetDebug(1);
for (Int_t i = 0; i < N; i++) {
if (! StarMagField::Instance()) new StarMagField;
StarMagField::Instance()->SetFactor(Data[i].field);
StEvtHddr *header = chain->GetEvtHddr();
header->SetRunNumber(i+1);
header->SetDateTime(20050101,i+1);
chain->MakeEvent();
db->SetDateTime(Data[i].date,Data[i].time);
St_Survey *SvtOnGlobal = (St_Survey *) chain->GetDataBase("Geometry/svt/SvtOnGlobal");
if (! SvtOnGlobal) {cout << "SvtOnGlobal has not been found" << endl; return 0;}
const TGeoHMatrix &Tpc2Global = gStTpcDb->Tpc2GlobalMatrix(); cout << "Tpc2Global\t"; Tpc2Global.Print();
TGeoHMatrix GL;
Survey_st *OnGlobal = SvtOnGlobal->GetTable(); // SVT and SVT as whole
GL.SetRotation(&OnGlobal->r00);
GL.SetTranslation(&OnGlobal->t0); cout << "GL\t"; GL.Print();
TGeoHMatrix TPCGL = Tpc2Global * GL; cout << "TPCGL\t"; TPCGL.Print();
TGeoHMatrix TPC2Inv = Tpc2Global.Inverse(); cout << "TPC2Inv\t"; TPC2Inv.Print();
TGeoHMatrix dR;
dR.RotateX(180./TMath::Pi()*Data[i].alpha*1e-3);
dR.RotateY(180./TMath::Pi()*Data[i].beta*1e-3);
dR.RotateZ(180./TMath::Pi()*Data[i].gamma*1e-3);
Double_t xyz[3], dxyz[3], drot[3];
xyz[0] = 1e-4*Data[i].dx;
xyz[1] = 1e-4*Data[i].dy;
xyz[2] = 1e-4*Data[i].dz;
dxyz[0] = 1e-4*Data[i].ddx;
dxyz[1] = 1e-4*Data[i].ddy;
dxyz[2] = 1e-4*Data[i].ddz;
drot[0] = Data[i].dalpha*1e-3;
drot[1] = Data[i].dbeta*1e-3;
drot[2] = Data[i].dgamma*1e-3;
dR.SetTranslation(xyz);
cout << "Additional rotation for Svt\t"; dR.Print();
TGeoHMatrix GLnew = TPC2Inv * dR * TPCGL; cout << "GLnew\t"; GLnew.Print();
Double_t *R = GLnew.GetRotationMatrix();
Survey_st row;
memcpy(&row.r00, R, 9*sizeof(Double_t));
Double_t *tr = GLnew.GetTranslation();
memcpy(&row.t0, tr, 3*sizeof(Double_t));
memcpy(&row.sigmaRotX, drot, 3*sizeof(Double_t));
memcpy(&row.sigmaTrX, dxyz, 3*sizeof(Double_t));
TString fOut = Form("SvtOnGlobal.%8i.%06i.C", Data[i].date, Data[i].time);
ofstream out;
cout << "Create " << fOut << endl;
out.open(fOut.Data());
out << "TDataSet *CreateTable() {" << endl;
out << " if (!gROOT->GetClass(\"St_Survey\")) return 0;" << endl;
out << " Survey_st row = " << endl;
out << "\t{0,"; out << endl; out << "\t";
Double_t *r = &(row.r00);
for (Int_t j = 0; j < 9; j++) out << Form("%f,",r[j]);
out << endl;
out << "\t";
for (Int_t j = 9; j < 12; j++) out << Form("%f,",r[j]);
out << endl;
out << "\t";
for (Int_t j = 12; j < 18; j++) out << Form("%f,",r[j]);
out << endl;
out << "\t";
out << "\"Run" << Data[i].run << " " << Data[i].comment << "\"};" << endl;
out << " St_Survey *tableSet = new St_Survey(\"SvtOnGlobal\",1);" << endl;
out << " tableSet->AddAt(&row.Id, 0);" << endl;
out << " return (TDataSet *)tableSet;" << endl;
out << "}" << endl;
out.close();
}
}
/**
* This is an alternative to bfcMixer_pythia() allowing the user to explicitly
* specify BFC options for all three chains.
*
* Sample input values:
*
* daqFileList = "@run10148002.list"
* fzdFile = "/path/to/my_pythia.fzd"
* flag = "W"
*
*/
void EmbeddingReco(const int nEvents, const std::string daqFileList, const std::string fzdFile,
const std::string bfcOptionsChain1, const std::string bfcOptionsChain2, const std::string bfcOptionsChain3,
const std::string flag)
{
// Dynamically link some shared libs
gROOT->LoadMacro("bfc.C");
if (gClassTable->GetID("StBFChain") < 0) Load();
//______________Create the main chain object______________________________________
Chain = new StChain("Embedding");
//________________________________________________________________________________
bfc(-1, bfcOptionsChain1.c_str(), daqFileList.c_str());
chain1 = chain;
chain1->SetName("One");
chain1->SetAttr(".call", "SetActive(0)", "St_db_Maker::"); // Use DB cache to reduce overhead
Chain->cd();
//________________________________________________________________________________
bfc(-1, bfcOptionsChain2.c_str(), fzdFile.c_str());
chain2 = chain;
chain2->SetName("Two");
Chain->cd();
if (chain2->GetOption("TRS")) {
StTrsMaker *trsMk = (StTrsMaker *) chain2->GetMaker("Trs");
if (!trsMk) {
cout << "Cannot find Trs in chain2" << endl;
return;
}
trsMk->setNormalFactor(1.32);
trsMk->SetMode(0);
}
//________________________________________________________________________________
// gSystem->Load("StFtpcMixerMaker");
// StFtpcMixerMaker *ftpcmixer = new StFtpcMixerMaker("FtpcMixer","daq","trs");
//________________________________________________________________________________
TString OutputFileName(gSystem->BaseName(fzdFile.c_str()));
OutputFileName.ReplaceAll("*", "");
OutputFileName.ReplaceAll(".fzd", "");
// OutputFileName.Append("_emb.root");
OutputFileName.Append(".root");
bfc(-1, bfcOptionsChain3.c_str(), 0, OutputFileName);
chain3 = chain;
chain3->SetName("Three");
Chain->cd();
//________________________________________________________________________________
StTpcMixerMaker *mixer = (StTpcMixerMaker *) chain3->Maker("TpcMixer");
mixer->SetInput("Input1", "TpxRaw/.data/Event");
if (bfcOptionsChain2.find("TpcRS") != std::string::npos) {
mixer->SetInput("Input2", "TpcRS/Event");
}
else {
mixer->SetInput("Input2", "Trs/.const/Event");
}
Chain->cd();
if (flag == "W") {
// blacklist some detectors to save DB load
St_db_Maker *dbMk = (St_db_Maker *)chain3->GetMaker("db");
dbMk->SetAttr("blacklist", "svt");
dbMk->SetAttr("blacklist", "ssd");
// dbMk->SetAttr("blacklist", "ftpc"); // S.F.
}
//------------------------------------ EMC MIXERS ------------------------------------
// Add BEMC mixer to chain3
StEmcRawMaker *emcRaw = (StEmcRawMaker *)chain3->GetMaker("emcRaw");
emcRaw->getBemcRaw()->saveAllStEvent(true); // use all 4800 BEMC towers
gSystem->Load("StEmcMixerMaker");
StEmcMixerMaker *bemcMixer = new StEmcMixerMaker;
chain3->AddAfter("EmcSimulator", bemcMixer);
// Set EEMC fast and slow simulator in embedding mode
StEEmcFastMaker *eefs = (StEEmcFastMaker *)chain3->GetMaker("eefs");
eefs->SetEmbeddingMode(); // Use local StEmcCollection
eefs->UseFullTower(true); // Use full ETOW detector
StEEmcSlowMaker *eess = new StEEmcSlowMaker;
eess->setEmbeddingMode(true);
// Add EEMC mixer to chain3
StEEmcMixerMaker *eemcMixer = new StEEmcMixerMaker;
//------------------------------------------------------------------------------------
//----------------------------- TRIGGER FILTER -----------------------------
// We want to achieve the following ordering for makers:
// 1. BBC simulator
// 2. BEMC simulator
// 3. BEMC mixer
// 4. EEMC fast simulator
// 5. EEMC slow simulator
// 6. EEMC mixer
// 7. Pythia event maker
// 8. Trigger simulator
// 9. Trigger filter
// 10. TPC maker
// Place TPC chain after EMC makers
chain3->AddAfter("eefs", chain3->GetMaker("tpcChain"));
chain3->AddAfter("eefs", eemcMixer);
chain3->AddAfter("eefs", eess);
if (flag == "Jet") {
// Place Pythia maker after GEANT maker
// and trigger filter after EMC makers
gSystem->Load("StJetSkimEvent");
gSystem->Load("StMCAsymMaker");
gSystem->Load("StBfcTriggerFilterMaker");
StPythiaEventMaker *pythia = new StPythiaEventMaker;
TString pyfile = gSystem->BaseName(fzdFile.c_str());
pyfile.ReplaceAll(".fzd", ".pythia.root");
pythia->SetPythiaFile(pyfile);
chain3->AddAfter("geant", pythia);
// Place trigger simulator after EMC makers
gSystem->Load("StTriggerUtilities");
StTriggerSimuMaker *trgsim = new StTriggerSimuMaker;
trgsim->setMC(1);
// BBC was not used in Run 9 jet triggers
//trgsim->useBbc();
//trgsim->bbc->setSource("StEvent");
trgsim->useBemc();
trgsim->bemc->setConfig(StBemcTriggerSimu::kOnline);
trgsim->useEemc();
trgsim->eemc->setSource("StEvent");
/*
trgsim->bemc->setBarrelJetPatchTh0(32);
trgsim->bemc->setBarrelJetPatchTh1(43);
trgsim->bemc->setBarrelJetPatchTh2(64);
*/
trgsim->setBarrelJetPatchTh(0, 32); // set for Run-11 based on trigger versioning page 20130728
trgsim->setBarrelJetPatchTh(1, 43);
trgsim->setBarrelJetPatchTh(2, 64);
trgsim->setOverlapJetPatchTh(0, 32);
trgsim->setOverlapJetPatchTh(1, 43);
trgsim->setOverlapJetPatchTh(2, 64);
trgsim->setEndcapJetPatchTh(0, 32);
trgsim->setEndcapJetPatchTh(1, 43);
trgsim->setEndcapJetPatchTh(2, 64);
trgsim->setBarrelHighTowerTh(0, 11);
trgsim->setBarrelHighTowerTh(1, 18);
trgsim->setBarrelHighTowerTh(2, 25);
trgsim->setBarrelHighTowerTh(3, 31);
trgsim->setEndcapHighTowerTh(0, 25);
trgsim->setEndcapHighTowerTh(1, 31);
// StBfcTriggerFilterMaker* trgfilt = new StBfcTriggerFilterMaker;
// no trigger filter for Run-11 VPDMB
// trgfilt->SetOkAllEvents(1);
// The BFC trigger filter will select only JP1, AJP and BHT3 events
// trgfilt->SetJP1();
// trgfilt->SetAJP();
// trgfilt->SetBHT3();
// Lower all jet patch thresholds by one unit from
// their values obtained from the database using
// the current timestamp.
//trgfilt->changeJPThresh(-1);
chain3->AddBefore("tpcChain", trgsim);
// chain3->AddBefore("tpcChain",trgfilt); // no trigger filter for Run-11 VPDMB
// Move these makers after trigger decision
// *** VERY IMPORTANT ***
// The order of TpxRaw and TpcRS *must* be preserved
// or the embedding will *not* work. [RT# 2299]
// http://www.star.bnl.gov/rt2/Ticket/Display.html?id=2299
StTpcRSMaker *TpcRS = (StTpcRSMaker *)chain2->GetMaker("TpcRS");
StTpcHitMaker *TpxRaw = (StTpcHitMaker *)chain1->GetMaker("TpxRaw");
chain3->AddBefore("TpcMixer", TpxRaw);
chain3->AddBefore("TpcMixer", TpcRS);
#if 0
// Turn on debugging of DB maker
St_db_Maker *db = (St_db_Maker *)chain1->GetMaker("db");
db->SetDebug(2);
#endif
//--------------------------------------------------------------------------
TString trgfile = gSystem->BaseName(fzdFile.c_str());
trgfile.ReplaceAll(".fzd", ".trig.root");
TFile *ofile = TFile::Open(trgfile, "recreate");
assert(ofile);
TH2F *hBarrelHighTowerSimu = new TH2F("hBarrelHighTowerSimu", "BEMC high tower simu;trigger patch;high tower", 300, 0, 300, 64, 0, 64);
TH2F *hBarrelPatchSumSimu = new TH2F("hBarrelPatchSumSimu", "BEMC patch sum simu;trigger patch;patch sum", 300, 0, 300, 64, 0, 64);
TH2F *hEndcapHighTowerSimu = new TH2F("hEndcapHighTowerSimu", "EEMC high tower simu;trigger patch;high tower", 90, 0, 90, 64, 0, 64);
TH2F *hEndcapPatchSumSimu = new TH2F("hEndcapPatchSumSimu", "EEMC patch sum simu;trigger patch;patch sum", 90, 0, 90, 64, 0, 64);
TH2F *hBarrelJetPatchSimu = new TH2F("hBarrelJetPatchSimu", "BEMC jet patch;jet patch;adc", 18, 0, 18, 160, 0, 160);
TH2F *hEndcapJetPatchSimu = new TH2F("hEndcapJetPatchSimu", "EEMC jet patch;jet patch;adc", 6, 0, 6, 160, 0, 160);
TH2F *hOverlapJetPatchSimu = new TH2F("hOverlapJetPatchSimu", "BEMC-EEMC-overlap;jet patch;adc", 6, 0, 6, 160, 0, 160);
}
//--------------------------------------------------------------------------
// Initialize chain
Chain->Init();
PrintTimer(Chain);
puts("Order of makers in BFCMIXER:");
StMaker::lsMakers(Chain);
// Event loop
int mNTotal = 0;
int mNFailed = 0;
TBenchmark evnt;
StIOMaker *inputStream = (StIOMaker *)chain1->GetMaker("inputStream");
for (int iEvent = 1; iEvent <= nEvents; ++iEvent) {
evnt.Reset();
evnt.Start("QAInfo:");
Chain->Clear();
int iMake = Chain->Make(iEvent);
if (iMake == kStErr) ++mNFailed;
if (inputStream->GetMakeReturn() % 10 == kStEOF) {
inputStream->Rewind();
--iEvent;
continue;
}
//if (iMake == kStSkip) continue;
if (iMake % 10 == kStEOF || iMake % 10 == kStFatal) break;
++mNTotal;
PrintTimer(Chain);
//--------------------------------------------------------------------------
if (flag == "Jet") {
// BEMC high towers and trigger patches
for (int triggerpatch = 0; triggerpatch < 300; ++triggerpatch) {
hBarrelHighTowerSimu->Fill(triggerpatch, trgsim->bemc->getBEMC_FEE_HT_ADC()[triggerpatch]);
hBarrelPatchSumSimu->Fill(triggerpatch, trgsim->bemc->getBEMC_FEE_TP_ADC()[triggerpatch]);
} // for triggerpatch
// BEMC jet patches
for (int jetpatch = 0; jetpatch < 18; ++jetpatch) {
hBarrelJetPatchSimu->Fill(jetpatch, trgsim->bemc->barrelJetPatchAdc(jetpatch));
} // for jetpatch
// EEMC high towers and trigger patches
for (int triggerpatch = 0; triggerpatch < 90; ++triggerpatch) {
hEndcapHighTowerSimu->Fill(triggerpatch, trgsim->eemc->getEndcapHighTower(triggerpatch));
hEndcapPatchSumSimu->Fill(triggerpatch, trgsim->eemc->getEndcapPatchSum(triggerpatch));
} // for triggerpatch
// EEMC jet patches
for (int jetpatch = 0; jetpatch < 6; ++jetpatch) {
hEndcapJetPatchSimu->Fill(jetpatch, trgsim->eemc->endcapJetPatchAdc(jetpatch));
} // for jetpatch
// BEMC-EEMC-overlap jet patches
for (int i = 0; i < 2; ++i) {
int jetpatch, adc;
trgsim->emc->getOverlapJetPatchAdc(i, jetpatch, adc);
hOverlapJetPatchSimu->Fill(jetpatch, adc);
} // for i
} //end of if("jet")
//--------------------------------------------------------------------------
evnt.Stop("QAInfo:");
printf("QAInfo: Done with Event [no. %d/run %d/evt. %d/Date.Time %d.%d/sta %d] Real Time = %10.2f seconds Cpu Time = %10.2f seconds\n", iEvent, Chain->GetRunNumber(), Chain->GetEventNumber(), Chain->GetDate(), Chain->GetTime(), chain3->GetMakeReturn(), evnt.GetRealTime("QAInfo:"), evnt.GetCpuTime("QAInfo:"));
} // End event loop
printf("QAInfo:EventLoop completed code %d\n", iMake);
gSystem->Exec("date");
TDatime t;
printf("QAInfo:Run is finished at Date/Time %i/%i; Total events processed: %i and not completed: %i\n", t.GetDate(), t.GetTime(), mNTotal, mNFailed);
//--------------------------------------------------------------------------
if (flag == "Jet") {
ofile->Write();
ofile->Close();
}
}
//________________________________________________________________________________
void MakeSvtLadderOnShell(){//, Int_t time = 38 ){ // combine SvtBarrelOnGlobal and SvtShellsOnBarrel into SvtShellsOnGlobal
gROOT->LoadMacro("bfc.C");
bfc(0,"mysql,db,nodefault");
StMaker *dbMk = chain->Maker("db");
if (! dbMk) return;
dbMk->SetDebug(1);
StEvtHddr *header = chain->GetEvtHddr();
header->SetRunNumber(1);
dbMk->SetDateTime(date,time);
header->SetDateTime(date,time);
chain->MakeEvent();
dbMk->SetDebug(2);
dbMk->SetDateTime(date,time);
St_Survey *LadderOnShellOld = (St_Survey *) dbMk->GetDataBase("Geometry/svt/LadderOnShell"); // shells in the SVT barrel coordinate system
if (! (LadderOnShellOld)) return;
Survey_st *LaddersOnShells = LadderOnShellOld->GetTable(); // shells in the SVT barrel coordinate system
Int_t NoLadders = LadderOnShellOld->GetNRows();
St_Survey *LadderOnShell = new St_Survey("LadderOnShell",NoLadders);
#ifdef CutSTEP
cout << "============================ CutSTEP =========================" << endl;
#endif
TGeoHMatrix T;
Double_t tr[3] = {0,0, 23.525};
// Double_t tr[3] = {0,0, -23.525};
T.SetTranslation(tr);
TGeoHMatrix F;
Double_t flip[9] = {
1, 0, 0,
0, 0, 1,
0, 1, 0
};
F.SetRotation(flip);
TGeoHMatrix TInv = T.Inverse();
for (Int_t s = 0; s < NoLadders; s++, LaddersOnShells++) {
TGeoHMatrix LSold, LS, dR, ddR, dddR;
// LadderOnShellOld->Print(s,1);
LSold.SetRotation(&LaddersOnShells->r00);
LSold.SetTranslation(&LaddersOnShells->t0); cout << "===================== Ladder \t" << s+1 << endl; cout << "\tLSold\t"; LSold.Print();
Int_t i = -1;
for (Int_t k = 0; k < N; k++) {
if (LaddersOnShells->Id == 1000*Data[k].barrel + Data[k].ladder) {i = k; break;}
}
if (i < 0) {
cout << "Correction for " << LaddersOnShells->Id << " is not found" << endl;
} else {
cout << "Ladder " << LaddersOnShells->Id << "\ti " << i
<< "\talpha " << Data[i].alpha << "+/-" << Data[i].Dalpha
<< "\tbeta " << Data[i].beta << "+/-" << Data[i].Dbeta
<< "\tgamma " << Data[i].gamma << "+/-" << Data[i].Dgamma
<< "\tu " << Data[i].u << "\tv " << Data[i].v << "\tw " << Data[i].w << endl;
Double_t xyz[3] = {0, 0, 0};
// if (Data[i].Dalpha < 2 && Data[i].Dbeta < 2 && Data[i].Dgamma < 2) {
#ifndef CutSTEP
if (Data[i].Dalpha > 0) dR.RotateX(-180./TMath::Pi()*Data[i].alpha*1e-3);
if (Data[i].Dbeta > 0) dR.RotateZ(-180./TMath::Pi()*Data[i].beta*1e-3);
if (Data[i].Dgamma > 0) dR.RotateY(-180./TMath::Pi()*Data[i].gamma*1e-3);
if (Data[i].Du > 0) xyz[0] = 1e-4*Data[i].u;
if (Data[i].Dv > 0) xyz[2] = 1e-4*Data[i].v;
if (Data[i].Dw > 0) xyz[1] = 1e-4*Data[i].w;
#else
if (Data[i].Dalpha > 0) dR.RotateX(-180./TMath::Pi()*Data[i].alpha*0.5e-3);
if (Data[i].Dbeta > 0) dR.RotateZ(-180./TMath::Pi()*Data[i].beta*0.5e-3);
if (Data[i].Dgamma > 0) dR.RotateY(-180./TMath::Pi()*Data[i].gamma*0.5e-3);
if (Data[i].Du > 0) xyz[0] = 0.5e-4*Data[i].u;
if (Data[i].Dv > 0) xyz[2] = 0.5e-4*Data[i].v;
if (Data[i].Dw > 0) xyz[1] = 0.5e-4*Data[i].w;
#endif
// }
dR.SetTranslation(xyz);
cout << "dR\t"; dR.Print();
}
// shellOnGlobal * ladderOnShell * T * dR * T**-1 * ladderOnSurvey * waferOnLadder
// shellOnGlobal * ( ladderOnShell * F * T * dR * T**-1 * F ) * ladderOnSurvey * waferOnLadder
ddR = T * dR * TInv; cout << "ddR\t" << ddR.Print();
dddR = F * T * dR * TInv * F; cout << "dddR\t" << dddR.Print();
// LS = LSold * dR; cout << "LS_old\t"; LS.Print();
// LS = LSold * dddR; cout << "LS_new\t"; LS.Print();
LS = LSold * ddR; cout << "LS_new\t"; LS.Print();
Survey_st row = *LaddersOnShells;
Double_t *r = LS.GetRotationMatrix();
memcpy(&row.r00, r, 9*sizeof(Double_t));
Double_t *t = LS.GetTranslation();
memcpy(&row.t0, t, 3*sizeof(Double_t));
LadderOnShell->AddAt(&row);
// LadderOnShell->Print(LadderOnShell->GetNRows()-1,1);
}
TString fOut = Form("%s.%8i.%06i.C",LadderOnShell->GetName(),date,time);
ofstream out;
cout << "Create " << fOut << endl;
out.open(fOut.Data());
out << "TDataSet *CreateTable() {" << endl;
out << " if (!gROOT->GetClass(\"St_Survey\")) return 0;" << endl;
out << " Survey_st row[" << NoLadders << "] = {" << endl;
Survey_st *LaddersOnShells = LadderOnShell->GetTable();
for (Int_t i = 0; i < NoLadders; i++, LaddersOnShells++) {
out << " {" << Form("%1i",LaddersOnShells->Id);
Double_t *r = &(LaddersOnShells->r00);
for (Int_t j = 0; j < 9; j++) out << Form(",%8.5f",r[j]);
for (Int_t j = 9; j < 12; j++) out << Form(",%8.4f",r[j]);
for (Int_t j = 12; j < 18; j++) out << Form(",%3.1f",r[j]);
out << ",\"" << Pass << "\"}";
if (i != NoLadders - 1) out << ",";
out << endl;
}
out << " };" << endl;
out << " St_Survey *tableSet = new St_Survey(\"" << LadderOnShell->GetName() << "\"," << NoLadders << ");" << endl;
out << " for (Int_t i = 0; i < " << NoLadders << "; i++) tableSet->AddAt(&row[i].Id, i);" << endl;
out << " return (TDataSet *)tableSet;" << endl;
out << "}" << endl;
out.close();
}
// ----------------------------------------------------------------------------
// ----------------------------------------------------------------------------
// ----------------------------------------------------------------------------
void starsim( Int_t nevents=1, Int_t rngSeed=4321 )
{
gROOT->ProcessLine(".L bfc.C");
{
TString simple = "y2012 geant gstar usexgeom agml ";
bfc(0, simple );
}
gSystem->Load( "libVMC.so");
gSystem->Load( "StarGeneratorUtil.so" );
gSystem->Load( "StarGeneratorEvent.so" );
gSystem->Load( "StarGeneratorBase.so" );
gSystem->Load( "libMathMore.so" );
gSystem->Load( "libHijing1_383.so");
gSystem->Load( "libKinematics.so");
gSystem->Load( "xgeometry.so" );
// force gstar load/call
gSystem->Load( "gstar.so" );
command("call gstar");
// Setup RNG seed and map all ROOT TRandom here
StarRandom::seed( rngSeed );
StarRandom::capture();
// Load STAR Particle DataBase and add the hypertriton definitions (as defined in gstar_part.g)
StarParticleData &pdb = StarParticleData::instance();
pdb.AddParticle("HyperTriton", new TParticlePDG( "HyperTriton", "HyperTriton --> He3 pi-", 2.99131, false, 0.0, +3.0, "hypernucleus", +hid(1,1,1), 0, 61054 ));
pdb.AddParticle("AntiHyperTriton", new TParticlePDG( "AntiHyperTriton", "AntiHyperTriton --> He3bar pi+", 2.99131, false, 0.0, -3.0, "hypernucleus", -hid(1,1,1), 0, 61055 ));
//
// Create the primary event generator and insert it
// before the geant maker
//
_primary = new StarPrimaryMaker();
{
_primary -> SetFileName( "hijing.starsim.root");
chain -> AddBefore( "geant", _primary );
}
// Setup an event generator
//
Hijing();
//
// Setup single hypertritons
//
HyperTritons();
//
// Initialize primary event generator and all sub makers
//
_primary -> Init();
//
// Setup geometry and set starsim to use agusread for input
//
//geometry("y2012");
command("gkine -4 0");
command("gfile o hijing.starsim.fzd");
//
// Trigger on nevents
//
trig( nevents );
_primary->event()->Print();
// command("gprint kine");
command("call agexit"); // Make sure that STARSIM exits properly
}
// ----------------------------------------------------------------------------
// ----------------------------------------------------------------------------
// ----------------------------------------------------------------------------
void starsim( Int_t nevents=10, Int_t rngSeed=4321 )
{
gROOT->ProcessLine(".L bfc.C");
{
TString simple = "y2014a geant gstar usexgeom agml ";
bfc(0, simple );
}
gSystem->Load( "libVMC.so");
gSystem->Load( "StarGeneratorUtil.so" );
gSystem->Load( "StarGeneratorEvent.so" );
gSystem->Load( "StarGeneratorBase.so" );
gSystem->Load( "libMathMore.so" );
gSystem->Load( "libHijing1_383.so");
gSystem->Load( "libKinematics.so");
gSystem->Load( "xgeometry.so" );
// force gstar load/call
gSystem->Load( "gstar.so" );
command("call gstar");
// Setup RNG seed and map all ROOT TRandom here
StarRandom::seed( rngSeed );
StarRandom::capture();
//
// Create the primary event generator and insert it
// before the geant maker
//
_primary = new StarPrimaryMaker();
{
_primary -> SetFileName( "hijing.starsim.root");
chain -> AddBefore( "geant", _primary );
}
//
// These should be adjusted to your best vertex estimates
//
_primary -> SetVertex( 0., 0., 0. );
_primary -> SetSigma( 0.3, 0.3, 60.0 );
// Setup an event generator
//
Hijing();
//
// Setup single dalitzdecay
//
Dalitzdecay();
//
// Initialize primary event generator and all sub makers
//
_primary -> Init();
//
// Setup geometry and set starsim to use agusread for input
//
command("gkine -4 0");
command("gfile o hijing.starsim.fzd");
//
// Trigger on nevents
//
trig( nevents );
_primary->event()->Print();
// command("gprint kine");
command("call agexit"); // Make sure that STARSIM exits properly
}
//_____________________________________________________________________
void bfcMixer_Ftpc(const Int_t Nevents=20,
const Char_t *daqfile="/star/rcf/test/daq/2008/emb/st_fmsslow_adc_9069059_raw_1520001.daq",
const Char_t *tagfile="/star/rcf/test/daq/2008/emb/daqtags/st_fmsslow_adc_9069059_raw_1520001.tags.root",
const Double_t pt_low=0.2,
const Double_t pt_high=0.5,
const Double_t eta_low=2.25,
const Double_t eta_high=4.45,
const Double_t vzlow = -50.0,
const Double_t vzhigh = 50.0,
const Int_t pid=8,
const Double_t mult=1,
const std::vector<Int_t> triggers = 0,
const Char_t *prodName = "P08iepp",
const Char_t* type = "FlatPt") {
// production chains for P08ic - p+p, Au+Au 9 GeV and d+Au
TString prodP08iepp("DbV20081117 B2008a ITTF IAna ppOpt l3onl emcDY2 fpd ftpc trgd ZDCvtx NosvtIT NossdIT Corr4 OSpaceZ2 OGridLeak3D VFMCE -hitfilt");
// TString prodP08icpp("DbV20080712,pp2008,ITTF,OSpaceZ2,OGridLeak3D,beamLine,VFMCE,TpxClu -VFPPV -hitfilt");
// TString prodP08icAuAu9("DbV20080709 P2008 ITTF VFMCE -hitfilt");
// TString prodP08icAuAu200("DbV20070101 P2008 ITTF VFMCE -hitfilt");
// TString prodP08icdAu("DbV20080712 P2008 ITTF OSpaceZ2 OGridLeak3D beamLine, VFMCE TpxClu -VFMinuit -hitfilt");
TString prodP08iedAu("DbV20090213 P2008 ITTF OSpaceZ2 OGridLeak3D beamLine VFMCE TpxClu -VFMinuit -hitfilt");
TString prodP10iapp("DbV20091001 pp2009c TpcRS ITTF OSpaceZ2 OGridLeak3D beamLine, VFMCE TpcRS -VFMinuit -hitfilt");
TString geomP08ic("ry2008");
TString chain1Opt("in,magF,tpcDb,NoDefault,TpxRaw,-ittf,NoOutput");
// TString chain2Opt("NoInput,PrepEmbed,gen_T,geomT,sim_T,TpcRS,-ittf,-tpc_daq,nodefault");
TString chain2Opt("NoInput,PrepEmbed,gen_T,geomT,sim_T,ftpcT,trs,fss,-ittf,-tpc_daq,nodefault");
chain2Opt += " ";
chain2Opt += geomP08ic;
TString chain3Opt("");
if (prodName == "P08icpp") {
chain3Opt = prodP08icpp;
}
else if (prodName == "P08iepp") {
chain3Opt = prodP08iepp;
}
else if (prodName == "P08icAuAu9") {
chain3Opt = prodP08icAuAu9;
}
else if (prodName == "P08icdAu") {
chain3Opt = prodP08icdAu;
}
else if (prodName == "P08iedAu") {
chain3Opt = prodP08iedAu;
}
else if (prodName == "P08icAuAu200") {
chain3Opt = prodP08icAuAu200;
}
else if (prodName == "P10iapp") {
chain3opt = prodP10iapp;
}
else {
cout << "Choice prodName does not correspond to known chain. Processing impossible. " << endl;
return;
}
chain3Opt += ",Embedding,TpcMixer,GeantOut,MiniMcMk,McAna,-in,NoInput,useInTracker";
chain3Opt += ",";
chain3Opt += geomP08ic;
// Dynamically link some shared libs
gROOT->LoadMacro("bfc.C");
if (gClassTable->GetID("StBFChain") < 0) Load();
//______________Create the main chain object______________________________________
Chain = new StChain("Embedding");
//________________________________________________________________________________
bfc(-1,chain1Opt,daqfile);
chain1 = chain;
chain1->SetName("One");
Chain->cd();
//________________________________________________________________________________
bfc(-1,chain2Opt);
chain2 = chain;
chain2->SetName("Two");
Chain->cd();
#if 1
if (chain2->GetOption("TRS")) {
StTrsMaker *trsMk = (StTrsMaker *) chain2->GetMaker("Trs");
if (! trsMk) {
cout << "Cannot find Trs in chain2" << endl;
return;
}
trsMk->setNormalFactor(1.32);
trsMk->SetMode(0);
}
#endif
//________________________________________________________________________________
gSystem->Load("StFtpcMixerMaker");
StFtpcMixerMaker *ftpcmixer = new StFtpcMixerMaker("FtpcMixer","daq","fss");
ftpcmixer->SetInput("Input1","StDAQReader");
ftpcmixer->SetInput("Input2","Event");
//________________________________________________________________________________
TString OutputFileName(gSystem->BaseName(daqfile));
OutputFileName.ReplaceAll("*","");
OutputFileName.ReplaceAll(".daq","");
// OutputFileName.Append("_emb.root");
OutputFileName.Append(".root");
bfc(-1,chain3Opt,0,OutputFileName);
chain3 = chain;
chain3->SetName("Three");
Chain->cd();
//________________________________________________________________________________
StTpcMixerMaker *mixer = (StTpcMixerMaker *) chain3->Maker("TpcMixer");
if( prodName == "P08icAuAu200")
{
mixer->SetInput("Input1","MixerEvent");
}
else
{
mixer->SetInput("Input1","TpxRaw/.data/Event");
}
mixer->SetInput("Input2","Trs/.const/Event");
Chain->cd();
#if 0
//............. begin of EMC embedding makers................
//.............. Add BEmc stuff here ....................
gSystem->Load("StEmcSimulatorMaker");
gSystem->Load("StEmcMixerMaker");
gSystem->Load("StEEmcSimulatorMaker");
StMcEventMaker* mcEventMaker = new StMcEventMaker();
StEmcSimulatorMaker *bemcSim = new StEmcSimulatorMaker();
StEmcMixerMaker *bemcMixer = new StEmcMixerMaker();
chain3->AddAfter("emcRaw",bemcMixer);
chain3->AddAfter("emcRaw",bemcSim);
chain3->AddAfter("emcRaw",mcEventMaker);
bemcMixer->SetDebug(0); // set it to 1 for more printouts
// note, Barrel slow sim is always ON, said Adam
//........... Add EEmc Stuff ( Simu, and Mixer) here ..............
StEEmcFastMaker *eemcFastSim = new StEEmcFastMaker();
StEEmcMixerMaker *eemcMixer = new StEEmcMixerMaker();
/* position B+E EMC makers in the chain
(order is reverse because 'After' is used - looks funny but is right)
*/
chain3->AddAfter("emcRaw",eemcMixer);
chain3->AddAfter("emcRaw",eemcFastSim);
eemcFastSim->SetEmbeddingMode();
// eemcFastSim->SetDebug();
// eemcMixer->SetDebug();
bool useEndcapSlowSim = true;
if(useEndcapSlowSim) { // turn Endcap slow simu On/Off
StEEmcSlowMaker *slowSim=new StEEmcSlowMaker();
chain3->AddAfter("EEmcFastSim",slowSim);
slowSim->setEmbeddingMode();
}
#endif
//________________________________________________________________________________
{
TDatime t;
gMessMgr->QAInfo() << Form("Run is started at Date/Time %i/%i",t.GetDate(),t.GetTime()) << endm;
}
gMessMgr->QAInfo() << Form("Run on %s in %s",gSystem->HostName(),gSystem->WorkingDirectory()) << endm;
gMessMgr->QAInfo() << Form("with %s", Chain->GetCVS()) << endm;
// embedded particle set
StPrepEmbedMaker *embMk = (StPrepEmbedMaker *) Chain->Maker("PrepEmbed");
if (! embMk) return;
cout << "bfcMixer: Setting PID: "<<pid<<endl;
embMk->SetTagFile(tagfile);
// pTlow,ptHigh,etaLow,etaHigh,phiLow,phiHigh
embMk->SetOpt( pt_low, pt_high, eta_low, eta_high, 0., 6.283185, type);
// pid, mult
embMk->SetPartOpt( pid,mult);
// Default is no event selections
embMk->SetSkipMode(kTRUE);
// Make trigger and z-vertex cuts (only if SkipMode is true)
// Trigger cut
// Can put multiple trigger id's
if ( !triggers.empty() ) {
for(std::vector<Int_t>::iterator iter = triggers.begin(); iter != triggers.end(); iter++) {
embMk->SetTrgOpt((*iter)) ;
}
}
// z-vertex cuts
embMk->SetZVertexCut(vzlow, vzhigh) ;
TAttr::SetDebug(0);
Chain->SetAttr(".Privilege",0,"*" ); //All makers are NOT priviliged
Chain->SetAttr(".Privilege",1,"StBFChain::*" ); //StBFChain is priviliged
Chain->SetAttr(".Privilege",1,"StIOInterFace::*" ); //All IO makers are priviliged
Chain->SetAttr(".Privilege",1,"St_geant_Maker::*"); //It is also IO maker
Chain->SetAttr(".Privilege",1,"StPrepEmbedMaker::*"); //It is also IO maker
// Chain->SetDEBUG(0);
if (Nevents < 0) return;
Int_t iInit = Chain->Init();
if (iInit >= kStEOF) {
Chain->FatalErr(iInit,"on init");
return;
}
StMaker *treeMk = Chain->GetMaker("outputStream");
Chain->EventLoop(Nevents,treeMk);
gMessMgr->QAInfo() << "Run completed " << endm;
gSystem->Exec("date");
}
void test( const std::string & meshFile, const uint_t numProcesses, const uint_t numTotalBlocks )
{
auto mesh = make_shared<MeshType>();
mesh::readAndBroadcast( meshFile, *mesh);
auto aabb = computeAABB( *mesh );
auto domainAABB = aabb.getScaled( typename MeshType::Scalar(3) );
auto triDist = make_shared< mesh::TriangleDistance<MeshType> >( mesh );
auto distanceOctree = make_shared< DistanceOctree< MeshType > >( triDist );
const real_t meshVolume = real_c( computeVolume( *mesh ) );
const real_t blockVolume = meshVolume / real_c( numTotalBlocks );
static const real_t cellsPersBlock = real_t(1000);
const real_t cellVolume = blockVolume / cellsPersBlock;
const Vector3<real_t> cellSize( std::pow( cellVolume, real_t(1) / real_t(3) ) );
ComplexGeometryStructuredBlockforestCreator bfc( domainAABB, cellSize, makeExcludeMeshInterior( distanceOctree, cellSize.min() ) );
auto wl = mesh::makeMeshWorkloadMemory( distanceOctree, cellSize );
wl.setInsideCellWorkload(0);
wl.setOutsideCellWorkload(1);
wl.setForceZeroMemoryOnZeroWorkload(true);
bfc.setWorkloadMemorySUIDAssignmentFunction( wl );
bfc.setRefinementSelectionFunction( makeRefinementSelection( distanceOctree, 5, cellSize[0], cellSize[0] * real_t(5) ) );
WALBERLA_LOG_INFO_ON_ROOT( "Creating SBF with StaticLevelwiseCurveBalanceWeighted Partitioner" );
bfc.setTargetProcessAssignmentFunction( blockforest::StaticLevelwiseCurveBalanceWeighted() );
auto sbf_default = bfc.createSetupBlockForest( Vector3<uint_t>(64,64,64), numProcesses );
//sbf_default->writeVTKOutput("sbf_default");
WALBERLA_LOG_INFO_ON_ROOT( sbf_default->toString() );
return;
#ifdef WALBERLA_BUILD_WITH_PARMETIS
WALBERLA_LOG_INFO_ON_ROOT( "Creating SBF with ParMetis (PART_KWAY, no commweights)" );
bfc.setTargetProcessAssignmentFunction( blockforest::StaticLevelwiseParMetis( blockforest::StaticLevelwiseParMetis::PARMETIS_PART_KWAY ) );
auto sbf = bfc.createSetupBlockForest( numTotalBlocks, numProcesses );
//sbf->writeVTKOutput("sbf");
WALBERLA_LOG_INFO_ON_ROOT( sbf->toString() );
WALBERLA_LOG_INFO_ON_ROOT( "Creating SBF with ParMetis (PART_KWAY, commweights)" );
bfc.setTargetProcessAssignmentFunction( blockforest::StaticLevelwiseParMetis( commInXDirection, blockforest::StaticLevelwiseParMetis::PARMETIS_PART_KWAY ) );
auto sbf_edge = bfc.createSetupBlockForest( numTotalBlocks, numProcesses );
//sbf_edge->writeVTKOutput("sbf_edge");
WALBERLA_LOG_INFO_ON_ROOT( sbf_edge->toString() );
WALBERLA_LOG_INFO_ON_ROOT( "Creating SBF with ParMetis (PART_GEOM_KWAY, no commweights)" );
bfc.setTargetProcessAssignmentFunction( blockforest::StaticLevelwiseParMetis( blockforest::StaticLevelwiseParMetis::PARMETIS_PART_GEOM_KWAY ) );
auto sbf_geom = bfc.createSetupBlockForest( numTotalBlocks, numProcesses );
//sbf_geom->writeVTKOutput("sbf_geom");
WALBERLA_LOG_INFO_ON_ROOT( sbf_geom->toString() );
WALBERLA_LOG_INFO_ON_ROOT( "Creating SBF with ParMetis (PART_GEOM_KWAY, commweights)" );
bfc.setTargetProcessAssignmentFunction( blockforest::StaticLevelwiseParMetis( commInXDirection, blockforest::StaticLevelwiseParMetis::PARMETIS_PART_GEOM_KWAY ) );
auto sbf_geom_edge = bfc.createSetupBlockForest( numTotalBlocks, numProcesses );
//sbf_geom_edge->writeVTKOutput("sbf_geom_edge");
WALBERLA_LOG_INFO_ON_ROOT( sbf_geom_edge->toString() );
#endif
}
//_____________________________________________________________________
void bfcZ(const Int_t First,
const Int_t Last,
const Char_t *Chain="gstar Cy2b tfs -NoHits TpcHitFilter",
const Char_t *infile=0,
const Double_t zmin=-200, const Double_t zmax=-100,
const Char_t *outfile=0,
const Char_t *TreeFile=0){
gROOT->LoadMacro("bfc.C");
bfc(-1,Chain,infile,outfile,TreeFile);
if (chain->GetOption("TpcHitFilter")) {
StTpcHitFilterMaker *filtMk = (StTpcHitFilterMaker *) chain->GetMaker("tpc_hit_filter");
if (filtMk) {
// St_tcl_Maker *tclMk= (St_tcl_Maker *) chain->GetMaker("tpc_hits");
if (zmin < 0 && zmax < 0) filtMk->WestOff();
if (zmin > 0 && zmax > 0) filtMk->EastOff();
filtMk->SetZrange(zmin,zmax);
}
}
{
TDatime t;
printf ("QAInfo:Run is started at Date/Time %i/%i\n",t.GetDate(),t.GetTime());
printf ("QAInfo:Run on %s in %s\n",
gSystem->HostName(),
gSystem->WorkingDirectory());
printf ("QAInfo: with %s\n", chain->GetCVS());
}
// Init the chain and all its makers
Int_t iTotal = 0, iBad = 0;
St_XDFFile *xdf_out = 0;
TBenchmark evnt;
Int_t iMake = 0, i = First;
if (Last >= 0) {
Int_t iInit = chain->Init();
if (iInit >= kStEOF) {
chain->Fatal(iInit,"on init");
goto END;
}
StEvtHddr *hd = (StEvtHddr*)chain->GetDataSet("EvtHddr");
if (hd) hd->SetRunNumber(-2); // to be sure that InitRun calls at least once
// skip if any
if (First > 1) {
if (chain->GetOption("fzin")) {
geant = (St_geant_Maker *) chain->GetMaker("geant");
if (geant) {
if (geant->IsActive()) geant->Skip(First-1);
}
}
else {
StIOMaker *inpMk = (StIOMaker *) chain->GetMaker("inputStream");
if (inpMk) {printf ("Skip %i Events\n",First-1);inpMk->Skip(First-1);}
}
}
}
xdf_out = chain->GetXdfOut();
if (chain->GetOption("Event")) evMk = (StEventMaker *) chain->GetMaker("StEventMaker");
treeMk = chain->GetMaker("OutputStream");
EventLoop: if (i <= Last && iMake != kStEOF && iMake != kStFatal) {
evnt.Reset();
evnt.Start("QAInfo:");
chain->Clear();
iMake = chain->Make(i);
if (iMake <kStEOF) {
if (xdf_out){
St_DataSet *dstSet = chain->GetInputDS("dst");
if (dstSet) xdf_out->NextEventPut(dstSet); // xdf output
}
iTotal++;
if (treeMk && iMake == kStErr) {treeMk->Make(i); iBad++;}
// gSystem->Exec("ps ux");
evnt.Stop("QAInfo:");
// evnt.Show("QAInfo:");
printf ("QAInfo: Done with Event [no. %d/run %d/evt. %d/Date.Time %d.%d/sta %d] Real Time = %10.2f seconds Cpu Time = %10.2f seconds \n",
i,chain->GetRunNumber(),chain->GetEventNumber(),chain->GetDate(), chain->GetTime(),
iMake,evnt.GetRealTime("QAInfo:"),evnt.GetCpuTime("QAInfo:"));
}
i++; goto EventLoop;
}
END:
fflush(stdout);
printf ("QAInfo:Run completed ");
gSystem->Exec("date");
if (evMk) Event = (StEvent *) chain->GetInputDS("StEvent");
{
TDatime t;
printf ("\nQAInfo:Run is finished at Date/Time %i/%i; Total events processed :%i and not completed: %i\n",
t.GetDate(),t.GetTime(),iTotal,iBad);
}
}
int AttachGalley(OBJECT hd, OBJECT *inners, OBJECT *suspend_pt)
{ OBJECT hd_index; /* the index of hd in the enclosing galley */
OBJECT hd_inners; /* inner galleys of hd, if unsized */
OBJECT dest; /* the target @Galley hd empties into */
OBJECT dest_index; /* the index of dest */
OBJECT target; /* the target indefinite containing dest */
OBJECT target_index; /* the index of target */
OBJECT target_galley; /* the body of target, made into a galley */
OBJECT tg_inners; /* inner galleys of target_galley */
BOOLEAN need_precedes = FALSE;/* true if destination lies before galley */
OBJECT recs; /* list of recursive definite objects */
OBJECT link, y = nilobj; /* for scanning through the components of hd */
CONSTRAINT c; /* temporary variable holding a constraint */
OBJECT env, n1, tmp, zlink, z, sym; /* placeholders and temporaries */
BOOLEAN was_sized; /* true if sized(hd) initially */
int dim; /* the galley direction */
FULL_LENGTH perp_back, perp_fwd;
OBJECT why, junk;
debug2(DGA, D, "[ AttachGalley(Galley %s into %s)",
SymName(actual(hd)), SymName(whereto(hd)));
ifdebug(DGA, DD, DebugGalley(hd, nilobj, 4));
assert( Up(hd) != hd, "AttachGalley: no index!" );
Parent(hd_index, Up(hd));
assert( type(hd_index) == UNATTACHED, "AttachGalley: not UNATTACHED!" );
hd_inners = tg_inners = nilobj;
was_sized = sized(hd);
dim = gall_dir(hd);
for(;;)
{
/*************************************************************************/
/* */
/* Search for a destination for hd. If hd is unsized, search for */
/* inner galleys preceding it first of all, then for receptive objects */
/* following it, possibly in inner galleys. If no luck, exit. */
/* If hd is sized, search only for receptive objects in the current */
/* galley below the current spot, and fail if cannot find any. */
/* */
/*************************************************************************/
sym = whereto(hd);
if( sized(hd) )
{
/* sized galley case: search on from current spot */
target_index = SearchGalley(Up(hd_index), sym, TRUE, FALSE, TRUE, TRUE);
if( target_index == nilobj )
{
/* search failed to find any new target, so kill the galley */
for( link = Down(hd); link != hd; link = NextDown(link) )
{ Child(y, link);
if( type(y) == SPLIT ) Child(y, DownDim(y, dim));
if( is_definite(type(y)) ) break;
}
if( link != hd )
Error(19, 1, "galley %s deleted from here (no target)",
WARN, &fpos(y), SymName(actual(hd)));
if( hd_inners != nilobj ) DisposeObject(hd_inners), hd_inners=nilobj;
if( tg_inners != nilobj ) DisposeObject(tg_inners), tg_inners=nilobj;
KillGalley(hd, FALSE);
*inners = nilobj;
debug0(DGA, D, "] AttachGalley returning ATTACH_KILLED");
return ATTACH_KILLED;
}
else if( actual(actual(target_index)) == InputSym )
{
/* search found input object, so suspend on that */
DeleteNode(hd_index);
Link(target_index, hd);
*inners = nilobj;
debug0(DGA, D, "] AttachGalley returning ATTACH_INPUT");
return ATTACH_INPUT;
}
}
else /* unsized galley, either backwards or normal */
{
if( foll_or_prec(hd) == GALL_PREC )
{ target_index= SearchGalley(Up(hd_index), sym, FALSE, TRUE,TRUE,FALSE);
need_precedes = FALSE;
}
else
{ target_index = SearchGalley(Up(hd_index), sym, FALSE,TRUE,FALSE,FALSE);
need_precedes = (target_index != nilobj);
if( target_index == nilobj )
target_index = SearchGalley(Up(hd_index), sym, TRUE,TRUE,TRUE,FALSE);
}
/* if no luck, exit without error */
if( target_index == nilobj )
{ *inners = nilobj;
debug0(DGA, D, "] AttachGalley returning ATTACH_NOTARGET");
return ATTACH_NOTARGET;
}
}
assert( type(target_index) == RECEPTIVE, "AttachGalley: target_index!" );
target = actual(target_index);
assert( type(target) == CLOSURE, "AttachGalley: target!" );
/* set target_galley to the expanded value of target */
debug1(DYY, D, "[ EnterErrorBlock(FALSE) (expanding target %s)",
SymName(actual(target)));
EnterErrorBlock(FALSE);
New(target_galley, HEAD);
force_gall(target_galley) = FALSE;
enclose_obj(target_galley) = limiter(target_galley) = nilobj;
ClearHeaders(target_galley);
opt_components(target_galley) = opt_constraints(target_galley) = nilobj;
gall_dir(target_galley) = external_hor(target) ? COLM : ROWM;
FposCopy(fpos(target_galley), fpos(target));
actual(target_galley) = actual(target);
whereto(target_galley) = ready_galls(target_galley) = nilobj;
foll_or_prec(target_galley) = GALL_FOLL;
must_expand(target_galley) = FALSE;
sized(target_galley) = FALSE;
/* get perpendicular constraint (none if horizontal galley) */
if( dim == ROWM )
{
Constrained(target, &c, 1-dim, &junk);
if( !constrained(c) )
Error(19, 2, "receptive symbol %s has unconstrained width",
FATAL, &fpos(target), SymName(actual(target)));
debug2(DSC, DD, "Constrained( %s, 1-dim ) = %s",
EchoObject(target), EchoConstraint(&c));
if( !FitsConstraint(0, 0, c) )
{ debug0(DGA, D, " reject: target_galley horizontal constraint is -1");
y = nilobj;
goto REJECT;
}
}
else /* actually unused */
SetConstraint(c, MAX_FULL_LENGTH, MAX_FULL_LENGTH, MAX_FULL_LENGTH);
debug1(DGA, DDD, " expanding %s", EchoObject(target));
tmp = CopyObject(target, no_fpos);
Link(target_galley, tmp);
env = DetachEnv(tmp);
debug4(DGM, D, " external_ver(%s) = %s, external_hor(%s) = %s",
SymName(actual(target)), bool(external_ver(target)),
SymName(actual(target)), bool(external_hor(target)));
SizeGalley(target_galley, env,
external_ver(target) || external_hor(target),
threaded(target), non_blocking(target_index),
trigger_externs(target_index), &save_style(target),
&c, whereto(hd), &dest_index, &recs, &tg_inners,
enclose_obj(hd) != nilobj ? CopyObject(enclose_obj(hd), no_fpos):nilobj);
debug1(DGA, DD, " SizeGalley tg_inners: %s", DebugInnersNames(tg_inners));
if( recs != nilobj ) ExpandRecursives(recs);
dest = actual(dest_index);
if( underline(dest) == UNDER_UNDEF ) underline(dest) = UNDER_OFF;
/* verify that hd satisfies any horizontal constraint on dest */
if( dim == ROWM )
{
debug1(DGA, DDD, " checking hor fit of hd in %s",SymName(actual(dest)));
Constrained(dest, &c, 1-dim, &junk);
debug3(DSC, DD, "Constrained( %s, %s ) = %s",
EchoObject(dest), dimen(1-dim), EchoConstraint(&c));
assert( constrained(c), "AttachGalley: dest unconstrained!" );
if( !FitsConstraint(0, 0, c) )
{ debug0(DGA, D, " reject: hd horizontal constraint is -1");
y = nilobj;
goto REJECT;
}
}
/* manifest and size the galley if not done yet */
if( !sized(hd) )
{
debug2(DYY, D, "[ EnterErrorBlock(TRUE) (sizing galley %s into %s)",
SymName(actual(hd)), SymName(whereto(hd)));
EnterErrorBlock(TRUE);
n1 = nilobj;
Child(y, Down(hd));
env = DetachEnv(y);
/*** threaded() only defined in ROWM case
SizeGalley(hd, env, TRUE, threaded(dest), non_blocking(target_index),
TRUE, &save_style(dest), &c, nilobj, &n1, &recs, &hd_inners);
*** */
SizeGalley(hd, env, TRUE, dim == ROWM ? threaded(dest) : FALSE,
non_blocking(target_index), TRUE, &save_style(dest), &c, nilobj,
&n1, &recs, &hd_inners, nilobj);
debug1(DGA,DD," SizeGalley hd_inners: %s", DebugInnersNames(hd_inners));
if( recs != nilobj ) ExpandRecursives(recs);
if( need_precedes ) /* need an ordering constraint */
{ OBJECT index1, index2;
New(index1, PRECEDES);
New(index2, FOLLOWS);
blocked(index2) = FALSE;
tmp = MakeWord(WORD, STR_EMPTY, no_fpos);
Link(index1, tmp); Link(index2, tmp);
Link(Up(hd_index), index1);
Link(Down(hd), index2);
debug0(DGA, D, " inserting PRECEDES and FOLLOWS");
}
LeaveErrorBlock(TRUE);
debug0(DYY, D, "] LeaveErrorBlock(TRUE) (finished sizing galley)");
}
if( dim == ROWM )
{ if( !FitsConstraint(back(hd, 1-dim), fwd(hd, 1-dim), c) )
{ debug3(DGA, D, " reject: hd %s,%s does not fit target_galley %s",
EchoLength(back(hd, 1-dim)), EchoLength(fwd(hd, 1-dim)),
EchoConstraint(&c));
Error(19, 3, "too little horizontal space for galley %s at %s",
WARN, &fpos(hd), SymName(actual(hd)), SymName(actual(dest)));
goto REJECT;
}
}
/* check status of first component of hd */
debug0(DGA, DDD, " now ready to attach; hd =");
ifdebug(DGA, DDD, DebugObject(hd));
for( link = Down(hd); link != hd; link = NextDown(link) )
{
Child(y, link);
debug1(DGA, DDD, " examining %s", EchoIndex(y));
if( type(y) == SPLIT ) Child(y, DownDim(y, dim));
switch( type(y) )
{
case EXPAND_IND:
case SCALE_IND:
case COVER_IND:
case GALL_PREC:
case GALL_FOLL:
case GALL_FOLL_OR_PREC:
case GALL_TARG:
case CROSS_PREC:
case CROSS_FOLL:
case CROSS_FOLL_OR_PREC:
case CROSS_TARG:
case PAGE_LABEL_IND:
break;
case PRECEDES:
case UNATTACHED:
if( was_sized )
{ /* SizeGalley was not called, so hd_inners was not set by it */
if( hd_inners == nilobj ) New(hd_inners, ACAT);
Link(hd_inners, y);
}
break;
case RECEPTIVE:
goto SUSPEND;
case RECEIVING:
goto SUSPEND;
case FOLLOWS:
Child(tmp, Down(y));
if( Up(tmp) == LastUp(tmp) )
{ link = pred(link, CHILD);
debug0(DGA, DD, " disposing FOLLOWS");
DisposeChild(NextDown(link));
break;
}
Parent(tmp, Up(tmp));
assert(type(tmp) == PRECEDES, "Attach: PRECEDES!");
switch( CheckComponentOrder(tmp, target_index) )
{
case CLEAR: DeleteNode(tmp);
link = pred(link, CHILD);
DisposeChild(NextDown(link));
break;
case PROMOTE: break;
case BLOCK: debug0(DGA, DD, "CheckContraint: BLOCK");
goto SUSPEND;
case CLOSE: debug0(DGA, D, " reject: CheckContraint");
goto REJECT;
}
break;
case GAP_OBJ:
underline(y) = underline(dest);
if( !join(gap(y)) ) seen_nojoin(hd) = TRUE;
break;
case BEGIN_HEADER:
case END_HEADER:
case SET_HEADER:
case CLEAR_HEADER:
/* do nothing until actually promoted out of here */
underline(y) = underline(dest);
break;
case CLOSURE:
case CROSS:
case FORCE_CROSS:
case NULL_CLOS:
case PAGE_LABEL:
underline(y) = underline(dest);
break;
case WORD:
case QWORD:
case ONE_COL:
case ONE_ROW:
case WIDE:
case HIGH:
case HSHIFT:
case VSHIFT:
case HMIRROR:
case VMIRROR:
case HSCALE:
case VSCALE:
case HCOVER:
case VCOVER:
case HCONTRACT:
case VCONTRACT:
case HLIMITED:
case VLIMITED:
case HEXPAND:
case VEXPAND:
case START_HVSPAN:
case START_HSPAN:
case START_VSPAN:
case HSPAN:
case VSPAN:
case ROTATE:
case BACKGROUND:
case SCALE:
case KERN_SHRINK:
case INCGRAPHIC:
case SINCGRAPHIC:
case PLAIN_GRAPHIC:
case GRAPHIC:
case LINK_SOURCE:
case LINK_DEST:
case LINK_DEST_NULL:
case LINK_URL:
case ACAT:
case HCAT:
case VCAT:
case ROW_THR:
case COL_THR:
underline(y) = underline(dest);
if( dim == ROWM )
{
/* make sure y is not joined to a target below (vertical only) */
for( zlink = NextDown(link); zlink != hd; zlink = NextDown(zlink) )
{ Child(z, zlink);
switch( type(z) )
{
case RECEPTIVE:
if( non_blocking(z) )
{ zlink = PrevDown(zlink);
DeleteNode(z);
}
else
{ y = z;
goto SUSPEND;
}
break;
case RECEIVING:
if( non_blocking(z) )
{ zlink = PrevDown(zlink);
while( Down(z) != z )
{ Child(tmp, Down(y));
if( opt_components(tmp) != nilobj )
{ DisposeObject(opt_components(tmp));
opt_components(tmp) = nilobj;
debug3(DOG, D, "AttachGalley(%s) de-optimizing %s %s",
SymName(actual(hd)), SymName(actual(tmp)), "(join)");
}
DetachGalley(tmp);
KillGalley(tmp, FALSE);
}
DeleteNode(z);
}
else
{ y = z;
goto SUSPEND;
}
break;
case GAP_OBJ:
if( !join(gap(z)) ) zlink = PrevDown(hd);
break;
default: break;
}
}
/* if HCAT, try vertical hyphenation (vertical galleys only) */
if( type(y) == HCAT ) VerticalHyphenate(y);
}
/* check availability of parallel space for the first component */
why = nilobj;
Constrained(dest, &c, dim, &why);
debug3(DGF, DD, " dest parallel Constrained(%s, %s) = %s",
EchoObject(dest), dimen(dim), EchoConstraint(&c));
if( !FitsConstraint(back(y, dim), fwd(y, dim), c) )
{ BOOLEAN scaled;
/* if forcing galley doesn't fit, try scaling first component */
scaled = FALSE;
if( force_gall(hd) && size(y, dim) > 0 )
{ int scale_factor;
scale_factor = ScaleToConstraint(back(y,dim), fwd(y,dim), &c);
if( scale_factor > 0.5 * SF )
{ char num1[20], num2[20];
sprintf(num1, "%.1fc", (float) size(y, dim) / CM);
sprintf(num2, "%.1fc", (float) bfc(c) / CM);
if( dim == ROWM )
Error(19, 4, "%s object too high for %s space; %s inserted",
WARN, &fpos(y), num1, num2, KW_SCALE);
else
Error(19, 5, "%s object too wide for %s space; %s inserted",
WARN, &fpos(y), num1, num2, KW_SCALE);
y = InterposeScale(y, scale_factor, dim);
scaled = TRUE;
}
}
/* otherwise we must reject, and warn the user */
if( !scaled )
{ char num1[20], num2[20];
debug3(DGA, D, " reject: vsize %s,%s in %s; y=",
EchoLength(back(y, dim)), EchoLength(fwd(y, dim)),
EchoConstraint(&c));
ifdebug(DGA, D, DebugObject(y));
if( size(y, dim) > 0 )
{ sprintf(num1, "%.1fc", (float) size(y, dim) / CM);
sprintf(num2, "%.1fc", (float) bfc(c) / CM);
if( dim == ROWM )
Error(19, 12, "%s object too high for %s space; will try elsewhere",
WARN, &fpos(y), num1, num2);
else
Error(19, 13, "%s object too wide for %s space; will try elsewhere",
WARN, &fpos(y), num1, num2);
}
goto REJECT;
}
}
/* check availability of perpendicular space for first component */
if( dim == ROWM )
{ perp_back = back(hd, 1-dim); perp_fwd = fwd(hd, 1-dim);
}
else
{ perp_back = back(y, 1-dim); perp_fwd = fwd(y, 1-dim);
}
Constrained(dest, &c, 1-dim, &junk);
debug3(DGF, DD, " dest perpendicular Constrained(%s, %s) = %s",
EchoObject(dest), dimen(1-dim), EchoConstraint(&c));
if( !FitsConstraint(perp_back, perp_fwd, c) )
{ BOOLEAN scaled;
/* if forcing galley doesn't fit, try scaling first component */
scaled = FALSE;
if( force_gall(hd) && perp_back + perp_fwd > 0 )
{ int scale_factor;
scale_factor = ScaleToConstraint(perp_back, perp_fwd, &c);
if( scale_factor > 0.5 * SF )
{ char num1[20], num2[20];
sprintf(num1, "%.1fc", (float) (perp_back + perp_fwd) / CM);
sprintf(num2, "%.1fc", (float) bfc(c) / CM);
if( 1-dim == ROWM )
Error(19, 6, "%s object too high for %s space; %s inserted",
WARN, &fpos(y), num1, num2, KW_SCALE);
else
Error(19, 7, "%s object too wide for %s space; %s inserted",
WARN, &fpos(y), num1, num2, KW_SCALE);
y = InterposeScale(y, scale_factor, 1-dim);
scaled = TRUE;
}
}
/* otherwise we must reject, and warn the user */
if( !scaled )
{
debug3(DGA, D, " reject: vsize %s,%s in %s; y=",
EchoLength(perp_back), EchoLength(perp_fwd),
EchoConstraint(&c));
ifdebug(DGA, D, DebugObject(y));
goto REJECT;
}
}
/* dest seems OK, so perform its size adjustments */
debug0(DSA, D, "calling AdjustSize from AttachGalley (a)");
AdjustSize(dest, back(y, dim), fwd(y, dim), dim);
debug0(DSA, D, "calling AdjustSize from AttachGalley (b)");
AdjustSize(dest, perp_back, perp_fwd, 1-dim);
/* now check parallel space for target_galley in target */
Constrained(target, &c, dim, &why);
debug3(DGF, DD, " target parallel Constrained(%s, %s) = %s",
EchoObject(target), dimen(dim), EchoConstraint(&c));
Child(z, LastDown(target_galley)); /* works in all cases? */
assert( !is_index(type(z)), "AttachGalley: is_index(z)!" );
assert( back(z, dim)>=0 && fwd(z, dim)>=0, "AttachGalley: z size!" );
if( !FitsConstraint(back(z, dim), fwd(z, dim), c) )
{ BOOLEAN scaled;
debug2(DGA, D, " why = %d %s", (int) why, EchoObject(why));
debug2(DGA, D, " limiter = %d %s", (int) limiter(hd),
EchoObject(limiter(hd)));
/* if forcing galley doesn't fit, try scaling z */
scaled = FALSE;
if( force_gall(hd) && size(z, dim) > 0 && limiter(hd) != why )
{ int scale_factor;
scale_factor = ScaleToConstraint(back(z,dim), fwd(z,dim), &c);
if( scale_factor > 0.5 * SF )
{ char num1[20], num2[20];
sprintf(num1, "%.1fc", (float) size(z, dim) / CM);
sprintf(num2, "%.1fc", (float) bfc(c) / CM);
if( dim == ROWM )
Error(19, 8, "%s object too high for %s space; %s inserted",
WARN, &fpos(y), num1, num2, KW_SCALE);
else
Error(19, 9, "%s object too wide for %s space; %s inserted",
WARN, &fpos(y), num1, num2, KW_SCALE);
z = InterposeWideOrHigh(z, dim);
z = InterposeScale(z, scale_factor, dim);
scaled = TRUE;
}
}
if( !scaled )
{ char num1[20], num2[20];
limiter(hd) = why;
debug3(DGA, D, " set limiter(%s) = %d %s", SymName(actual(hd)),
(int) limiter(hd), EchoObject(limiter(hd)));
debug3(DGA, D, " reject: size was %s,%s in %s; y =",
EchoLength(back(z, dim)), EchoLength(fwd(z, dim)),
EchoConstraint(&c));
ifdebug(DGA, D, DebugObject(y));
if( size(z, dim) > 0 )
{ sprintf(num1, "%.1fc", (float) size(z, dim) / CM);
sprintf(num2, "%.1fc", (float) bfc(c) / CM);
if( dim == ROWM )
Error(19, 14, "%s object too high for %s space; will try elsewhere",
WARN, &fpos(y), num1, num2);
else
Error(19, 15, "%s object too wide for %s space; will try elsewhere",
WARN, &fpos(y), num1, num2);
}
goto REJECT;
}
}
limiter(hd) = why;
debug3(DGA, D, " set limiter(%s) = %d %s", SymName(actual(hd)),
(int) limiter(hd), EchoObject(limiter(hd)));
/* now check perpendicular space for target_galley in target */
Constrained(target, &c, 1-dim, &junk);
debug3(DGF, DD, " target perpendicular Constrained(%s, %s) = %s",
EchoObject(target), dimen(1-dim), EchoConstraint(&c));
Child(z, LastDown(target_galley)); /* works in all cases? */
assert( !is_index(type(z)), "AttachGalley: is_index(z)!" );
assert( back(z, 1-dim)>=0 && fwd(z, 1-dim)>=0,
"AttachGalley: z size (perpendicular)!" );
if( !FitsConstraint(back(z, 1-dim), fwd(z, 1-dim), c) )
{ BOOLEAN scaled;
/* if forcing galley doesn't fit, try scaling z */
scaled = FALSE;
if( force_gall(hd) && size(z, 1-dim) > 0 )
{ int scale_factor;
scale_factor = ScaleToConstraint(back(z,1-dim), fwd(z,1-dim), &c);
if( scale_factor > 0.5 * SF )
{ char num1[20], num2[20];
sprintf(num1, "%.1fc", (float) size(z, 1-dim) / CM);
sprintf(num2, "%.1fc", (float) bfc(c) / CM);
if( 1-dim == ROWM )
Error(19, 10, "%s object too high for %s space; %s inserted",
WARN, &fpos(y), num1, num2, KW_SCALE);
else
Error(19, 11, "%s object too wide for %s space; %s inserted",
WARN, &fpos(y), num1, num2, KW_SCALE);
z = InterposeWideOrHigh(z, 1-dim);
z = InterposeScale(z, scale_factor, 1-dim);
scaled = TRUE;
}
}
if( !scaled )
{
debug3(DGA, D, " reject: size was %s,%s in %s; y =",
EchoLength(back(z, 1-dim)), EchoLength(fwd(z, 1-dim)),
EchoConstraint(&c));
ifdebug(DGA, D, DebugObject(y));
goto REJECT;
}
}
/* target seems OK, so adjust sizes and accept */
if( external_hor(target) )
{
/* don't adjust any sizes, none to adjust */
debug0(DSA, D, "not calling AdjustSize from AttachGalley (c)");
}
else if( external_ver(target) )
{
/* adjust perp size only, to galley size */
debug0(DSA, D, "calling AdjustSize from AttachGalley (d)");
AdjustSize(target, back(target_galley, 1-dim),
fwd(target_galley, 1-dim), 1-dim);
}
else
{
/* adjust both directions, using z (last component) */
Child(z, LastDown(target_galley));
debug0(DSA, D, "AttachGalley AdjustSize using z =");
ifdebug(DSA, D, DebugObject(z));
debug0(DSA, D, "calling AdjustSize from AttachGalley (e)");
AdjustSize(target, back(z, dim), fwd(z, dim), dim);
debug0(DSA, D, "calling AdjustSize from AttachGalley (f)");
AdjustSize(target, back(z, 1-dim), fwd(z, 1-dim), 1-dim);
}
goto ACCEPT;
default:
assert1(FALSE, "AttachGalley:", Image(type(y)));
break;
} /* end switch */
} /* end for */
/* null galley: promote whole galley without expanding the target */
debug0(DGA, D, " null galley");
if( tg_inners != nilobj ) DisposeObject(tg_inners), tg_inners = nilobj;
DisposeObject(target_galley);
LeaveErrorBlock(FALSE);
debug0(DYY, D, "] LeaveErrorBlock(FALSE) (null galley)");
/* kill off any null objects within the galley, then transfer it */
/* don't use Promote() since it does extra unwanted things here */
for( link = Down(hd); link != hd; link = NextDown(link) )
{ Child(y, link);
switch( type(y) )
{
case GAP_OBJ:
case CLOSURE:
case CROSS:
case FORCE_CROSS:
case NULL_CLOS:
case PAGE_LABEL:
link = PrevDown(link);
debug1(DGA, D, " null galley, disposing %s", Image(type(y)));
DisposeChild(NextDown(link));
break;
default:
break;
}
}
TransferLinks(NextDown(hd), hd, Up(target_index));
/* attach hd temporarily to target_index */
MoveLink(Up(hd), target_index, PARENT);
assert( type(hd_index) == UNATTACHED, "AttachGalley: type(hd_index)!" );
DeleteNode(hd_index);
/* return; only hd_inners needs to be flushed now */
*inners = hd_inners;
debug0(DGA, D, "] AttachGalley returning ATTACH_NULL");
return ATTACH_NULL;
REJECT:
/* reject first component */
/* debug1(DGA, D, " reject %s", EchoObject(y)); */
debug0(DGA, D, " reject first component");
LeaveErrorBlock(TRUE);
debug0(DYY, D, "] LeaveErrorBlock(TRUE) (REJECT)");
if( tg_inners != nilobj ) DisposeObject(tg_inners), tg_inners = nilobj;
DisposeObject(target_galley);
if( foll_or_prec(hd) == GALL_PREC && !sized(hd) )
{
/* move to just before the failed target */
MoveLink(Up(hd_index), Up(target_index), PARENT);
}
else
{
/* move to just after the failed target */
MoveLink(Up(hd_index), NextDown(Up(target_index)), PARENT);
}
continue;
SUSPEND:
/* suspend at first component */
debug1(DGA, D, " suspend %s", EchoIndex(y));
blocked(y) = TRUE;
LeaveErrorBlock(FALSE);
debug0(DYY, D, "] LeaveErrorBlock(FALSE) (SUSPEND)");
if( tg_inners != nilobj ) DisposeObject(tg_inners), tg_inners = nilobj;
DisposeObject(target_galley);
MoveLink(Up(hd_index), Up(target_index), PARENT);
if( was_sized )
{ /* nothing new to flush if suspending and already sized */
if( hd_inners != nilobj ) DisposeObject(hd_inners), hd_inners=nilobj;
*inners = nilobj;
}
else
{ /* flush newly discovered inners if not sized before */
*inners = hd_inners;
}
debug0(DGA, D, "] AttachGalley returning ATTACH_SUSPEND");
*suspend_pt = y;
return ATTACH_SUSPEND;
ACCEPT:
/* accept first component; now committed to the attach */
debug3(DGA, D, " accept %s %s %s", Image(type(y)), EchoObject(y),
EchoFilePos(&fpos(y)));
LeaveErrorBlock(TRUE);
debug0(DYY, D, "] LeaveErrorBlock(TRUE) (ACCEPT)");
/* attach hd to dest */
MoveLink(Up(hd), dest_index, PARENT);
assert( type(hd_index) == UNATTACHED, "AttachGalley: type(hd_index)!" );
DeleteNode(hd_index);
/* move first component of hd into dest */
/* nb Interpose must be done after all AdjustSize calls */
if( dim == ROWM && !external_ver(dest) )
Interpose(dest, VCAT, hd, y);
else if( dim == COLM && !external_hor(dest) )
{ Interpose(dest, ACAT, y, y);
Parent(junk, Up(dest));
assert( type(junk) == ACAT, "AttachGalley: type(junk) != ACAT!" );
StyleCopy(save_style(junk), save_style(dest));
adjust_cat(junk) = padjust(save_style(junk));
}
debug1(DGS, D, "calling Promote(hd, %s) from AttachGalley/ACCEPT",
link == hd ? "hd" : "NextDown(link)");
Promote(hd, link == hd ? hd : NextDown(link), dest_index, TRUE);
/* move target_galley into target */
/* nb Interpose must be done after all AdjustSize calls */
if( !(external_ver(target) || external_hor(target)) )
{ Child(z, LastDown(target_galley));
Interpose(target, VCAT, z, z);
}
debug0(DGS, D, "calling Promote(target_galley) from AttachGalley/ACCEPT");
Promote(target_galley, target_galley, target_index, TRUE);
DeleteNode(target_galley);
assert(Down(target_index)==target_index, "AttachGalley: target_ind");
if( blocked(target_index) ) blocked(dest_index) = TRUE;
DeleteNode(target_index);
/* return; both tg_inners and hd_inners need to be flushed now; */
/* if was_sized, hd_inners contains the inners of the first component; */
/* otherwise it contains the inners of all components, from SizeGalley */
if( tg_inners == nilobj ) *inners = hd_inners;
else if( hd_inners == nilobj ) *inners = tg_inners;
else
{ TransferLinks(Down(hd_inners), hd_inners, tg_inners);
DeleteNode(hd_inners);
*inners = tg_inners;
}
debug0(DGA, D, "] AttachGalley returning ATTACH_ACCEPT");
ifdebug(DGA, D,
if( dim == COLM && !external_hor(dest) )
{ OBJECT z;
Parent(z, Up(dest));
debug2(DGA, D, " COLM dest_encl on exit = %s %s",
Image(type(z)), EchoObject(z));
}
)
return ATTACH_ACCEPT;
} /* end for */
void FlushGalley(OBJECT hd)
{ OBJECT dest; /* the target galley hd empties into */
OBJECT dest_index; /* the index of dest */
OBJECT inners; /* list of galleys and PRECEDES to flush */
OBJECT link, y; /* for scanning through the components of hd */
int dim; /* direction of galley */
CONSTRAINT dest_par_constr; /* the parallel size constraint on dest */
CONSTRAINT dest_perp_constr; /* the perpendicular size constraint on dest */
int pb, pf, f; /* candidate replacement sizes for dest */
OBJECT dest_encl; /* the VCAT or ACAT enclosing dest, if any */
int dest_side; /* if dest_encl != nilobj, side dest is on */
BOOLEAN need_adjust; /* TRUE as soon as dest_encl needs adjusting */
FULL_LENGTH dest_back, dest_fwd; /* the current size of dest_encl or dest */
FULL_LENGTH frame_size; /* the total constraint of dest_encl */
OBJECT prec_gap; /* the gap preceding dest if any else nilobj */
OBJECT prec_def; /* the component preceding dest, if any */
OBJECT succ_gap; /* the gap following dest if any else nilobj */
OBJECT succ_def; /* the component following dest, if any */
OBJECT stop_link; /* most recently seen gap link of hd */
FULL_LENGTH stop_back; /* back(dest_encl) incl all before stop_link */
FULL_LENGTH stop_fwd; /* fwd(dest_encl) incl. all before stop_link */
FULL_LENGTH stop_perp_back; /* back(dest_encl) in other direction */
FULL_LENGTH stop_perp_fwd; /* fwd(dest_encl) in other direction */
BOOLEAN prnt_flush; /* TRUE when the parent of hd needs a flush */
BOOLEAN target_is_internal; /* TRUE if flushing into an internal target */
BOOLEAN headers_seen; /* TRUE if a header is seen at all */
OBJECT zlink, z, tmp, prnt; int attach_status; BOOLEAN remove_target;
OBJECT why;
FULL_LENGTH perp_back, perp_fwd; /* current perp size of dest_encl */
debug1(DGF, D, "[ FlushGalley %s (hd)", SymName(actual(hd)));
prnt_flush = FALSE;
dim = gall_dir(hd);
RESUME:
assert( type(hd) == HEAD, "FlushGalley: type(hd) != HEAD!" );
debug1(DGF, D, " resuming FlushGalley %s, hd =", SymName(actual(hd)));
ifdebugcond(DGF, DD, actual(hd) == nilobj, DebugGalley(hd, nilobj, 4));
assert( Up(hd) != hd, "FlushGalley: resume found no parent to hd!" );
/*@@************************************************************************/
/* */
/* The first step is to examine the parent of galley hd to determine the */
/* status of the galley. If this is not suitable for flushing, we do */
/* what we can to change the status. If still no good, return; so if */
/* this code does not return, then the galley is ready to flush into a */
/* destination in the normal way, and the following variables are set: */
/* */
/* dest_index the parent of the galley and index of its destination */
/* dest the destination of the galley, a @Galley object */
/* */
/***************************************************************************/
Parent(dest_index, Up(hd));
switch( type(dest_index) )
{
case DEAD:
/* the galley has been killed off while this process was sleeping */
debug1(DGF, D, "] FlushGalley %s returning (DEAD)", SymName(actual(hd)));
return;
case UNATTACHED:
/* the galley is currently not attached to a destination */
attach_status = AttachGalley(hd, &inners, &y);
debug1(DGF, DD, " ex-AttachGalley inners: %s", DebugInnersNames(inners));
Parent(dest_index, Up(hd));
switch( attach_status )
{
case ATTACH_KILLED:
assert(inners==nilobj, "FlushGalley/ATTACH_KILLED: inners!=nilobj!");
debug1(DGF, D, "] FlushGalley %s returning (ATTACH_KILLED)",
SymName(actual(hd)));
debug1(DGF, D, " prnt_flush = %s", bool(prnt_flush));
return;
case ATTACH_INPUT:
ParentFlush(prnt_flush, dest_index, FALSE);
assert(inners==nilobj, "FlushGalley/ATTACH_INPUT: inners!=nilobj!");
debug1(DGF, D, "] FlushGalley %s returning (ATTACH_INPUT)",
SymName(actual(hd)));
return;
case ATTACH_NOTARGET:
ParentFlush(prnt_flush, dest_index, FALSE);
assert(inners==nilobj, "FlushGalley/ATTACH_NOTARG: inners!=nilobj!");
debug1(DGF, D, "] FlushGalley %s returning (ATTACH_NOTARGET)",
SymName(actual(hd)));
return;
case ATTACH_SUSPEND:
/* AttachGalley only returns inners here if they really need to */
/* be flushed; in particular the galley must be unsized before */
if( inners != nilobj )
{
debug0(DGF, DD, " calling FlushInners() from FlushGalley (a)");
FlushInners(inners, nilobj);
goto RESUME;
}
stop_link = nilobj;
goto SUSPEND; /* nb y will be set by AttachGalley in this case */
case ATTACH_NULL:
/* hd will have been linked to the unexpanded target in this case */
remove_target = (actual(actual(dest_index)) == whereto(hd));
if( force_gall(hd) )
{
/* if hd is a forcing galley, close all predecessors */
debug3(DGA, D, " forcing ATTACH_NULL case for %s into %s (%s)",
SymName(actual(hd)), SymName(whereto(hd)),
remove_target ? "remove_target" : "not remove_target");
Parent(prnt, Up(dest_index));
if( !non_blocking(dest_index) && remove_target )
{
/* ***
prnt_flush = TRUE;
*** */
prnt_flush = non_blocking(dest_index) = TRUE;
}
FreeGalley(prnt, Up(dest_index), &inners, Up(dest_index),
whereto(hd));
}
else
{
debug3(DGA, D, " non-force ATTACH_NULL case for %s into %s (%s)",
SymName(actual(hd)), SymName(whereto(hd)),
remove_target ? "remove_target" : "not remove_target");
if( blocked(dest_index) && remove_target ) prnt_flush = TRUE;
}
DetachGalley(hd);
KillGalley(hd, TRUE);
if( inners != nilobj )
{
debug0(DGF, DD, " calling FlushInners() from FlushGalley (b)");
FlushInners(inners, nilobj);
}
else ParentFlush(prnt_flush, dest_index, remove_target);
debug0(DGF, D, "] FlushGalley returning ATTACH_NULL");
return;
case ATTACH_ACCEPT:
/* if hd is a forcing galley, or actual(dest_index) is */
/* @ForceGalley, then close all predecessors */
if( force_gall(hd) || actual(actual(dest_index)) == ForceGalleySym )
{ Parent(prnt, Up(dest_index));
debug1(DGA, D, " forcing ATTACH_ACCEPT case for %s",
SymName(actual(hd)));
/* debug0(DGA, DD, " force: prnt ="); */
/* ifdebug(DGA, DD, DebugObject(prnt)); */
/* debug1(DGA, D," calling FreeGalley from FlushGalley(%s)", */
/* SymName(actual(hd))); */
if( !non_blocking(dest_index) ) prnt_flush = TRUE; /* bug fix */
FreeGalley(prnt, Up(dest_index), &inners, Up(dest_index),
whereto(hd));
/* debug0(DGA, DD, " force: after FreeGalley, prnt ="); */
/* ifdebug(DGA, DD, DebugObject(prnt)); */
}
else prnt_flush = prnt_flush || blocked(dest_index);
debug1(DGF, DD, " force: prnt_flush = %s", bool(prnt_flush));
if( inners != nilobj )
{
debug0(DGF, DD, " calling FlushInners() from FlushGalley (c)");
FlushInners(inners, nilobj);
}
goto RESUME;
default:
assert(FALSE, "FlushGalley: attach_status");
break;
}
break;
case RECEIVING:
if( actual(actual(dest_index)) == InputSym )
{ ParentFlush(prnt_flush, dest_index, FALSE);
debug1(DGF, D, "] FlushGalley %s retn, input", SymName(actual(hd)));
return;
}
break;
default:
assert1(FALSE, "FlushGalley: dest_index", Image(type(dest_index)));
break;
}
dest = actual(dest_index);
if( underline(dest) == UNDER_UNDEF ) underline(dest) = UNDER_OFF;
target_is_internal =
(dim==ROWM && !external_ver(dest)) || (dim==COLM && !external_hor(dest));
headers_seen = FALSE;
debug1(DGF, DD, " dest_index: %s", EchoObject(dest_index));
/*@@************************************************************************/
/* */
/* The second step is to examine the components of the galley one by one */
/* to determine if they can be promoted. Each component has the format */
/* */
/* { <index> } <object> */
/* */
/* and is always followed by a gap object (except the last component). */
/* An index indicates that the following object has some interesting */
/* feature, and it points to that feature inside the object. There are */
/* two possible actions for each component, in addition to accepting it: */
/* */
/* REJECT: The component does not fit, so detach the galley */
/* SUSPEND: The component is incomplete; go to sleep and wait */
/* */
/***************************************************************************/
stop_link = dest_encl = inners = nilobj;
need_adjust = FALSE;
/***************************************************************************/
/* */
/* Loop invariant */
/* */
/* The children of hd up to but not including Child(link) have been */
/* examined and pronounced to be promotable, if unbreakable gaps are */
/* ignored. When unbreakable gaps are taken into account, the most */
/* recent gap where a break is possible is at Child(stop_link), or */
/* nowhere if stop_link == nilobj. */
/* */
/* Case 1: target_is_internal == FALSE */
/* */
/* If this flag is FALSE, it means that the target of this galley is */
/* external. Consequently, there is no need to calculate sizes because */
/* there is no constraint on them. Also, a REJECT action is impossible */
/* so unbreakable gaps are no impediment. Variable dest_encl is nilobj. */
/* */
/* Case 2: target_is_internal == TRUE */
/* */
/* If this flag is TRUE, it means that the target of this galley is */
/* internal. Consequently, sizes need to be calculated, and unbreakable */
/* gaps need to be taken into account. Variable dest_encl may be not */
/* nilobj, in which case the following variables are defined: */
/* */
/* dest_encl the object enclosing dest (which must exist) */
/* prec_gap gap object preceding dest (which must exist) */
/* prec_def first definite object preceding dest (must exist) */
/* dest_back back(dest_encl) including effect of accepted compts */
/* dest_fwd fwd(dest_encl) including effect of accepted compts */
/* dest_side BACK or FWD, i.e. which side of the mark dest is on */
/* dest_par_constr the parallel size constraint on dest */
/* dest_perp_constr the perpendicular size constraint on dest */
/* frame_size size of frame enclosing dest_encl */
/* perp_back back(dest_encl) in other direction, incl accepteds */
/* perp_fwd fwd(dest_encl) in other direction, incl accepteds */
/* */
/* if dest_encl is nilobj, these variables are not defined. */
/* */
/* If stop_link is non-nilobj, then in the internal case dest_encl must */
/* be non-nilobj, and the following variables are defined: */
/* */
/* stop_back back(dest_encl) including all before stop_link */
/* stop_fwd fwd(dest_encl) including all before stop_link */
/* stop_perp_back back(dest_encl) in other direction */
/* stop_perp_fwd fwd(dest_encl) in other direction */
/* */
/* need_adjust is true if at least one definite component has been */
/* accepted for promotion and the destination is internal; hence, */
/* dest_encl is defined and its size needs to be adjusted. */
/* */
/* inners is the set of all PRECEDES and UNATTACHED indexes found. */
/* */
/***************************************************************************/
for( link = Down(hd); link != hd; link = NextDown(link) )
{
Child(y, link);
if( type(y) == SPLIT ) Child(y, DownDim(y, dim));
debug2(DGF, DD, " examining %s %s", Image(type(y)), EchoObject(y));
switch( type(y) )
{
case GAP_OBJ:
underline(y) = underline(dest);
prec_gap = y;
if( target_is_internal )
{
/* *** not necessarily true
assert( dest_encl != nilobj, "FlushGalley/GAP_OBJ: dest_encl!" );
*** */
if( dest_encl != nilobj && !nobreak(gap(prec_gap)) )
{
stop_link = link;
stop_back = dest_back;
stop_fwd = dest_fwd;
stop_perp_back = perp_back;
stop_perp_fwd = perp_fwd;
}
}
else stop_link = link;
if( !join(gap(y)) ) seen_nojoin(hd) = TRUE;
break;
case SCALE_IND:
case COVER_IND:
case EXPAND_IND:
case GALL_PREC:
case GALL_FOLL:
case GALL_FOLL_OR_PREC:
case GALL_TARG:
case CROSS_PREC:
case CROSS_FOLL:
case CROSS_FOLL_OR_PREC:
case CROSS_TARG:
case PAGE_LABEL_IND:
underline(y) = underline(dest);
break;
case PRECEDES:
case UNATTACHED:
if( inners == nilobj ) New(inners, ACAT);
Link(inners, y);
break;
case RECEIVING:
case RECEPTIVE:
goto SUSPEND;
case FOLLOWS:
Child(tmp, Down(y));
if( Up(tmp) == LastUp(tmp) )
{ link = PrevDown(link);
DisposeChild(NextDown(link));
break;
}
Parent(tmp, Up(tmp));
assert(type(tmp) == PRECEDES, "Flush: PRECEDES!");
switch( CheckComponentOrder(tmp, dest_index) )
{
case CLEAR: DeleteNode(tmp);
link = PrevDown(link);
DisposeChild(NextDown(link));
break;
case PROMOTE: break;
case BLOCK: goto SUSPEND;
case CLOSE: if( opt_components(hd) != nilobj )
{ DisposeObject(opt_components(hd));
opt_components(hd) = nilobj;
debug2(DOG, D, "FlushGalley(%s) de-optimizing %s",
"(CLOSE problem)", SymName(actual(hd)));
}
debug1(DGF, DD, " reject (a) %s", EchoObject(y));
goto REJECT;
}
break;
case BEGIN_HEADER:
case END_HEADER:
case SET_HEADER:
case CLEAR_HEADER:
/* do nothing except take note, until actually promoted out of here */
headers_seen = TRUE;
break;
case NULL_CLOS:
case PAGE_LABEL:
case WORD:
case QWORD:
case ONE_COL:
case ONE_ROW:
case WIDE:
case HIGH:
case HSHIFT:
case VSHIFT:
case HSCALE:
case VSCALE:
case HCOVER:
case VCOVER:
case HCONTRACT:
case VCONTRACT:
case HLIMITED:
case VLIMITED:
case HEXPAND:
case VEXPAND:
case START_HVSPAN:
case START_HSPAN:
case START_VSPAN:
case HSPAN:
case VSPAN:
case ROTATE:
case BACKGROUND:
case SCALE:
case KERN_SHRINK:
case INCGRAPHIC:
case SINCGRAPHIC:
case PLAIN_GRAPHIC:
case GRAPHIC:
case LINK_SOURCE:
case LINK_DEST:
case ACAT:
case HCAT:
case VCAT:
case ROW_THR:
case CLOSURE:
case CROSS:
case FORCE_CROSS:
underline(y) = underline(dest);
if( dim == ROWM )
{
/* make sure y is not joined to a target below (vertical case only) */
for( zlink = NextDown(link); zlink != hd; zlink = NextDown(zlink) )
{ Child(z, zlink);
switch( type(z) )
{
case RECEPTIVE:
case RECEIVING: y = z;
goto SUSPEND;
case GAP_OBJ: if( !join(gap(z)) ) zlink = PrevDown(hd);
break;
default: break;
}
}
/* try vertical hyphenation before anything else */
if( type(y) == HCAT ) VerticalHyphenate(y);
}
/* check size constraint */
if( target_is_internal )
{
/* initialise dest_encl etc if not done yet */
if( dest_encl == nilobj )
{ assert( UpDim(dest,1-dim) == UpDim(dest,dim), "FlushG: UpDims!" );
/* *** weird old code, trying for UpDim(dest, ROWM)?
Parent(dest_encl, NextDown(Up(dest)));
*** */
Parent(dest_encl, Up(dest));
debug4(DGF, DD, " flush dest = %s %s, dest_encl = %s %s",
Image(type(dest)), EchoObject(dest),
Image(type(dest_encl)), EchoObject(dest_encl));
assert( (dim==ROWM && type(dest_encl)==VCAT) ||
(dim==COLM && type(dest_encl)==ACAT),
"FlushGalley: dest != VCAT or ACAT!" );
SetNeighbours(Up(dest), FALSE, &prec_gap, &prec_def,
&succ_gap, &succ_def, &dest_side);
assert(prec_gap != nilobj || is_indefinite(type(y)),
"FlushGalley: prec_gap == nilobj && !is_indefinite(type(y))!" );
assert(succ_gap == nilobj, "FlushGalley: succ_gap != nilobj!" );
assert(dest_side == FWD || is_indefinite(type(y)),
"FlushGalley: dest_side != FWD || !is_indefinite(type(y))!");
dest_back = back(dest_encl, dim);
dest_fwd = fwd(dest_encl, dim);
perp_back = back(dest_encl, 1-dim);
perp_fwd = fwd(dest_encl, 1-dim);
Constrained(dest_encl, &dest_par_constr, dim, &why);
Constrained(dest_encl, &dest_perp_constr, 1-dim, &why);
debug1(DGF, DD, " setting dest_perp_constr = %s",
EchoConstraint(&dest_perp_constr));
frame_size = constrained(dest_par_constr) ? bfc(dest_par_constr) :0;
}
if( !is_indefinite(type(y)) )
{
ifdebugcond(DGF, DD, mode(gap(prec_gap)) == NO_MODE,
DebugGalley(hd, y, 4));
/* calculate parallel effect of adding y to dest */
f = dest_fwd + fwd(y, dim) - fwd(prec_def, dim) +
ActualGap(fwd(prec_def, dim), back(y, dim),
fwd(y, dim), &gap(prec_gap), frame_size,
dest_back + dest_fwd - fwd(prec_def, dim));
debug5(DGF, DD, " f = %s + %s - %s + %s (prec_gap %s)",
EchoLength(dest_fwd), EchoLength(fwd(y, dim)),
EchoLength(fwd(prec_def, dim)), EchoLength(
ActualGap(fwd(prec_def, dim), back(y, dim),
fwd(y, dim), &gap(prec_gap), frame_size,
dest_back + dest_fwd - fwd(prec_def, dim))
), EchoGap(&gap(prec_gap)));
debug3(DGF, DD, " b,f: %s,%s; dest_encl: %s",
EchoLength(dest_back), EchoLength(f),
EchoConstraint(&dest_par_constr));
/* check new size against parallel constraint */
if( (units(gap(prec_gap))==FRAME_UNIT && width(gap(prec_gap)) > FR)
|| !FitsConstraint(dest_back, f, dest_par_constr)
|| (opt_components(hd) != nilobj && opt_comps_permitted(hd)<=0)
)
{
if( opt_components(hd) != nilobj )
{ OBJECT z;
/* record the size of this just-completed target area for hd */
New(z, WIDE);
CopyConstraint(constraint(z), dest_par_constr);
Link(opt_constraints(hd), z);
ifdebug(DOG, D,
debug2(DOG, D, "FlushGalley(%s) adding constraint %s",
SymName(actual(hd)), EchoConstraint(&constraint(z)));
if( units(gap(prec_gap))==FRAME_UNIT &&
width(gap(prec_gap)) > FR )
{ debug1(DOG, D, " prec_gap = %s", EchoGap(&gap(prec_gap)));
}
if( !FitsConstraint(dest_back, f, dest_par_constr) )
{ debug3(DOG, D, " !FitsConstraint(%s, %s, %s)",
EchoLength(dest_back), EchoLength(f),
EchoConstraint(&dest_par_constr));
}
if( opt_comps_permitted(hd) <= 0 )
{ debug1(DOG, D, " opt_comps_permitted = %2d",
opt_comps_permitted(hd));
}
debug4(DOG, D, "prec_gap = %s; y = %s (%s,%s):",
EchoGap(&gap(prec_gap)), Image(type(y)),
EchoLength(back(y, dim)), EchoLength(fwd(y, dim)));
DebugObject(y);
)
/* refresh the number of components permitted into the next target */
if( opt_counts(hd) != nilobj && Down(opt_counts(hd)) != opt_counts(hd) )
{ Child(z, Down(opt_counts(hd)));
opt_comps_permitted(hd) += comp_count(z) - 1;
DisposeChild(Up(z));
}
else opt_comps_permitted(hd) = MAX_FILES; /* a large number */
debug1(DOG, D, " REJECT permitted = %2d", opt_comps_permitted(hd));
}
debug1(DGF, DD, " reject (b) %s", EchoObject(y));
goto REJECT;
}
/* calculate perpendicular effect of adding y to dest */
if( seen_nojoin(hd) )
{
pb = 0;
pf = find_max(perp_fwd, size(y, 1-dim));
}
else
{
pb = find_max(perp_back, back(y, 1-dim));
pf = find_max(perp_fwd, fwd(y, 1-dim));
}
/* check new size against perpendicular constraint */
if( !FitsConstraint(pb, pf, dest_perp_constr) )
{
if( opt_components(hd) != nilobj )
{ DisposeObject(opt_components(hd));
opt_components(hd) = nilobj;
debug1(DOG, D, "FlushGalley(%s) de-optimizing (perp problem)",
SymName(actual(hd)));
}
if( dim == ROWM )
{
Error(20, 3, "component too wide for available space",
WARN, &fpos(y));
debug6(DGF, DD, " %s,%s [%s,%s] too wide for %s, y = %s",
EchoLength(pb), EchoLength(pf),
EchoLength(back(y, 1-dim)), EchoLength(fwd(y, 1-dim)),
EchoConstraint(&dest_perp_constr), EchoObject(y));
}
debug1(DGF, DD, " reject (c) %s", EchoObject(y));
goto REJECT;
}
/* accept definite component */
dest_fwd = f; prec_def = y;
perp_back = pb; perp_fwd = pf;
need_adjust = TRUE;
if( opt_components(hd) != nilobj )
{ opt_comps_permitted(hd)--;
debug1(DOG, D, " ACCEPT permitted = %2d", opt_comps_permitted(hd));
}
}
/* accept indefinite component */
} /* end if( target_is_internal ) */
void starsim( Int_t nevents=10, Int_t Index = 0, Int_t rngSeed=4321 )
{
gROOT->ProcessLine(".L bfc.C");
{
TString simple = "y2013_1c geant gstar usexgeom agml ";
bfc(0, simple );
}
gSystem->Load( "libVMC.so");
gSystem->Load( "StarGeneratorUtil.so" );
gSystem->Load( "StarGeneratorEvent.so" );
gSystem->Load( "StarGeneratorBase.so" );
gSystem->Load( "StarGeneratorDecay.so" );
gSystem->Load( "libMathMore.so" );
gSystem->Load( "libHijing1_383.so");
gSystem->Load( "libKinematics.so");
gSystem->Load( "xgeometry.so" );
gSystem->Load("libHepMC2_06_09.so");
gSystem->Load("libPythia8_1_86.so");
gSystem->Load("libPhotos3_61.so");
gSystem->Load("libTauola1_1_5.so");
gSystem->Load("libEvtGen1_06_00.so");
// Setup RNG seed and map all ROOT TRandom here
StarRandom::seed( rngSeed );
StarRandom::capture();
// char rootname[100],fzname[100];
// sprintf(rootname,"st_pythiaevtgen_%d.starsim.root",Index);
// sprintf(fzname,"gfile o st_pythiaevtgen_%d.starsim.fzd",Index);
TString rootname = "pythia6.reader.root";
TString fzname = "gfile o pythia6.reader.fzd";
//
// Create the primary event generator and insert it
// before the geant maker
//
_primary = new StarPrimaryMaker();
{
_primary -> SetFileName(rootname);
chain -> AddBefore( "geant", _primary );
}
//
// These should be adjusted to your best vertex estimates
//
_primary -> SetVertex( vx,vy,vz );
_primary -> SetSigma( vx_sig,vy_sig,vz_sig );
//
// Setup an event generator
//
// Pythia6("pp:W");
Pythia6( "pythia6.standalone.root" ); // input
//
// Setup decay manager
//
StarDecayManager *decayMgr = AgUDecay::Manager();
//
// Output a decay table for taus which specifies Tauola as the decay model
//
{
ofstream out("TAUS.DEC");
const char* cmds[] = {
"Decay tau-", // 1
"1.0 TAUOLA 0;", // 2
"Enddecay", // 3
"CDecay tau+", // 4
"End" // 5
};
for ( int i=0;i<5;i++ )
{
out << cmds[i] << endl;
}
}
// //
// // Setup EvtGen to decay most particles in STAR
// //
// StarEvtGenDecayer *decayEvt = new StarEvtGenDecayer();
// decayEvt->SetDecayTable("TAUS.DEC");
// decayMgr->AddDecayer( 23, decayEvt ); // Handle any decay requested
// decayMgr->AddDecayer( +15, decayEvt ); // Handle any decay requested [tau+]
// decayMgr->AddDecayer( -15, decayEvt ); // Handle any decay requested [tau-]
// decayEvt->SetDebug(0);
//
// Setup pythia8 to decay W+ and W- (and possibly others...)
//
StarPythia8Decayer *decayPy8 = new StarPythia8Decayer();
decayMgr -> AddDecayer( 0, decayPy8 );
decayMgr->AddDecayer( +24, decayPy8 );
decayMgr->AddDecayer( -24, decayPy8 );
decayMgr->AddDecayer( +23, decayPy8 );
decayMgr->AddDecayer( -23, decayPy8 );
decayPy8->SetDebug(1);
// Allow W to e+ nu or e- nu only
decayPy8->Set("24:onMode = 0");
decayPy8->Set("24:onIfAny = 11 -11");
decayPy8->Set("23:onMode = 0");
decayPy8->Set("23:onIfAny = 15 -15");
//
// Initialize primary event generator and all sub makers
//
_primary -> Init();
//return;
//
// Setup geometry and set starsim to use agusread for input
//
geometry("y2013_1c");
command("gkine -4 0");
command(fzname);
//
// Limits on eta, pt, ...
//
_primary->SetPtRange(0,-1.0); // no limits
_primary->SetEtaRange(-2.5,2.5);
//
// Trigger on nevents
//
trig( nevents );
// _primary->event()->Print();
command("call agexit"); // Make sure that STARSIM exits properly
// command("gprint kine");
}
//_____________________________________________________________________
void bfcMixer_TpcSvtSsd(const Int_t Nevents=500,Int_t isSvtIn=1, Int_t isSsdIn=1,
const Char_t *daqfile="/star/rcf/test/daq/2007/113/8113044/st_physics_8113044_raw_1040042.daq",
const Char_t *tagfile="/star/rcf/test/embedding/2007ProductionMinBias/FullField/P08if/2007/113/8113044/st_physics_8113044_raw_1040042.tags.root",
const Double_t pt_low=0.1,
const Double_t pt_high=5.0,
const Double_t eta_low=-1.1,
const Double_t eta_high=1.1,
const Double_t vzlow=-175.0,
const Double_t vzhigh=175.0,
const Int_t pid=8,
const Double_t mult = 100.,
const std::vector<Int_t> triggers = 0,
const Char_t* prodName = "P08icAuAu",
const Char_t* mode="flatpt"
) {
// Separate DB timestamp to add it in both chain1 and chain3
TString DbVP06idpp("DbV20060729 ");
TString DbVP07icCuCu("DbV20070518 ");
TString DbVP08icAuAu("DbV20080418 ");
// production chains for P06id - p+p 200 GeV (Run6)
TString prodP06idpp("pp2006b ITTF OSpaceZ2 OGridLeak3D VFMCE -VFPPVnoCTB -hitfilt");
// production chain for P07ib
// TString prodP07ib("P2005b DbV20070518 MakeEvent ITTF Iana ToF spt SsdIt SvtIt pmdRaw SCEbyE OGridLeak OShortR OSpaceZ2 ssd_daq");// KeepSvtHit hitfilt skip1row");
// production chain for P07ic - Cu+Cu 200 GeV (Run5)
TString prodP07icCuCu("P2005b DbV20070518 MakeEvent ITTF ToF ssddat spt SsdIt SvtIt pmdRaw OGridLeak OShortR OSpaceZ2 KeepSvtHit skip1row VFMCE -VFMinuit -hitfilt");
// production chain for P08if
// TString prodP08if("B2007g DbV20080418 adcOnly MakeEvent ITTF Iana ToF spt SsdIt SvtIt pmdRaw SCEbyE OShortR trgd Corr5 OSpaceZ2 ssd_daq KeepSvtHit -hitfilt VFMCE");// KeepSvtHit hitfilt skip1row");
// Production chain for P08ic Au+Au 200 GeV (Run7)
TString prodP08icAuAu("B2007g ITTF adcOnly IAna KeepSvtHit VFMCE -hitfilt l3onl emcDY2 fpd ftpc trgd ZDCvtx svtIT ssdIT Corr5 -dstout");
TString geomP06id("ry2006");
TString geomP07ic("ry2005f");
TString geomP08ic("ry2007g");
// TString chain1Opt("in magF tpcDb adcOnly NoDefault -ittf NoOutput");
TString chain1Opt("in magF tpcDb NoDefault -ittf NoOutput");
TString chain2Opt("NoInput PrepEmbed gen_T geomT sim_T trs -ittf -tpc_daq nodefault");
TString chain3Opt("");
if( prodName == "P06idpp") {
chain1Opt.Prepend(DbVP06idpp);
chain2Opt += " "; chain2Opt += geomP06id;
chain3Opt = prodP06idpp ;
}
else if( prodName == "P07ic" ){
chain1Opt.Prepend(DbVP07icCuCu);
chain2Opt += " "; chain2Opt += geomP07ic;
chain3Opt = prodP07icCuCu;
}
else if ( prodName == "P08icAuAu" ){
chain1Opt.Prepend(DbVP08icAuAu);
chain2Opt += " "; chain2Opt += geomP08ic;
chain3Opt = prodP08icAuAu ;
}
else{
cout << "Choice prodName does not correspond to known chain. Processing impossible. " << endl;
return;
}
// chain3Opt += " Embedding onlraw GeantOut MiniMcMk McAna IdTruth -in NoInput,useInTracker EmbeddingShortCut";
// chain3Opt += " Embedding onlraw McEvent McEvOut GeantOut MiniMcMk McAna IdTruth -in NoInput,useInTracker -hitfilt EmbeddingShortCut";
chain3Opt += " TpcMixer Embedding onlraw McEvent McEvOut GeantOut MiniMcMk McAna IdTruth -in NoInput,useInTracker -hitfilt -TrsPileUp -TrsToF";
// chain3Opt += " Embedding onlraw McEvent McEvOut GeantOut IdTruth -in NoInput -hitfilt EmbeddingShortCut";
if (isSvtIn) chain3Opt += " SvtEmbed";
if (isSsdIn) {
chain1Opt += ",ssddat";
chain2Opt += ",ssd,McEvent,-spt";
chain3Opt += ",SsdEmbed";
}
if( prodName == "P06idpp") {
chain3Opt.Prepend(DbVP06idpp);
chain3Opt += " "; chain3Opt += geomP06id;
}
else if( prodName == "P07ic" ){
chain3Opt.Prepend(DbVP07icCuCu);
chain3Opt += " "; chain3Opt += geomP07ic;
}
else if ( prodName == "P08icAuAu" ){
chain3Opt.Prepend(DbVP08icAuAu);
chain3Opt += " "; chain3Opt += geomP08ic;
}
else{
cout << "Choice prodName does not correspond to known chain. Processing impossible. " << endl;
return;
}
// Dynamically link some shared libs
gROOT->LoadMacro("bfc.C");
if (gClassTable->GetID("StBFChain") < 0) Load();
//______________Create the main chain object______________________________________
Chain = new StChain("Embedding");
//________________________________________________________________________________
bfc(-1,chain1Opt,daqfile);
chain1 = chain;
chain1->SetName("One");
Chain->cd();
//________________________________________________________________________________
bfc(-1,chain2Opt);
chain2 = chain;
chain2->SetName("Two");
Chain->cd();
if (chain2->GetOption("TRS")){
StTrsMaker *trsMk = (StTrsMaker *) chain2->GetMaker("Trs");
if (! trsMk) {
cout << "Cannot find Trs in chain2" << endl;
return;
}
trsMk->setNormalFactor(1.05);
trsMk->SetMode(0);
}
//________________________________________________________________________________
// gSystem->Load("StFtpcMixerMaker");
// StFtpcMixerMaker *ftpcmixer = new StFtpcMixerMaker("FtpcMixer","daq","trs");
//________________________________________________________________________________
TString OutputFileName(gSystem->BaseName(daqfile));
OutputFileName.ReplaceAll("*","");
OutputFileName.ReplaceAll(".daq","");
// OutputFileName.Append("_emb.root");
OutputFileName.Append(".root");
bfc(-1,chain3Opt,0,OutputFileName);
chain3 = chain;
chain3->SetName("Three");
Chain->cd();
Chain->cd();
//________________________________________________________________________________
{
TDatime t;
gMessMgr->QAInfo() << Form("Run is started at Date/Time %i/%i",t.GetDate(),t.GetTime()) << endm;
}
gMessMgr->QAInfo() << Form("Run on %s in %s",gSystem->HostName(),gSystem->WorkingDirectory()) << endm;
gMessMgr->QAInfo() << Form("with %s", Chain->GetCVS()) << endm;
// embedded particle set
StPrepEmbedMaker *embMk = (StPrepEmbedMaker *) Chain->Maker("PrepEmbed");
if (! embMk) return;
embMk->SetTagFile(tagfile);
// pTlow,ptHigh,etaLow,etaHigh,phiLow,phiHigh
embMk->SetOpt( pt_low, pt_high, eta_low, eta_high, 0., 6.283185, mode);
// pid, mult
embMk->SetPartOpt( pid,mult);
// Set Skip mode (default is OFF)
embMk->SetSkipMode(kFALSE) ;
// Make trigger and z-vertex cuts (only if SkipMode is true)
// Trigger cut
// Can put multiple trigger id's
if ( !triggers.empty() ){
for(std::vector<Int_t>::iterator iter = triggers.begin(); iter != triggers.end(); iter++){
embMk->SetTrgOpt((*iter)) ;
}
}
// z-vertex cuts
embMk->SetZVertexCut(vzlow, vzhigh) ;
TAttr::SetDebug(0);
Chain->SetAttr(".Privilege",0,"*" ); //All makers are NOT priviliged
Chain->SetAttr(".Privilege",1,"StBFChain::*" ); //StBFChain is priviliged
Chain->SetAttr(".Privilege",1,"StIOInterFace::*" ); //All IO makers are priviliged
Chain->SetAttr(".Privilege",1,"St_geant_Maker::*"); //It is also IO maker
Chain->SetAttr(".Privilege",1,"StPrepEmbedMaker::*"); //It is also IO maker
StMaker *SsdEmbed = Chain->Maker("SsdEmbed");
if (SsdEmbed) {
cout << "SsdEmbed has been found ----------------------------------------" << endl;
SsdEmbed->SetInput("SsdRealData","One/.make/SpaStrip/.data/spa_strip");
SsdEmbed->SetInput("SsdSimuData","Two/.make/SpaStrip/.data/spa_strip");
StMaker *SsdPoint = Chain->Maker("SsdPoint");
if (SsdPoint) {
cout << "SsdPoint has been found----------------------------------------" << endl;
SsdPoint->SetInput("SpaStrip","SsdEmbed");
}
}
// Chain->SetDEBUG(0);
if (Nevents < 0) return;
Int_t iInit = Chain->Init();
if (iInit >= kStEOF) {Chain->FatalErr(iInit,"on init"); return;}
StMaker *treeMk = Chain->GetMaker("outputStream");
Chain->EventLoop(Nevents,treeMk);
gMessMgr->QAInfo() << "Run completed " << endm;
gSystem->Exec("date");
}
//_____________________________________________________________________
void bfcMixer_TpcSvtSsd2005(const Int_t Nevents=100,Int_t isSvtIn=1, Int_t isSsdIn=1,
const Char_t *daqfile="/star/rcf/test/daq/2005/051/st_physics_adc_6051006_raw_1050001.daq",
const Char_t *tagfile="/star/rcf/test/embedding/cuProductionMinBias/FullField/P07ic/2005/051/st_physics_adc_6051006_raw_1050001.tags.root",
const Double_t pt_low=0.1,
const Double_t pt_high=5.0,
const Double_t eta_low=-1.0,
const Double_t eta_high=1.0,
const Int_t pid=9,
const Double_t mult = 0.1) {
// production chain for P07ib
TString prodP07ib("P2005b DbV20070518 MakeEvent ITTF Iana ToF spt SsdIt SvtIt pmdRaw SCEbyE OGridLeak OShortR OSpaceZ2 ssd_daq");// KeepSvtHit hitfilt skip1row");
TString geomP07ib("ry2005f");
TString chain1Opt("in magF tpcDb NoDefault -ittf NoOutput");
TString chain2Opt("NoInput PrepEmbed gen_T geomT sim_T trs -ittf -tpc_daq nodefault");
chain2Opt += " "; chain2Opt += geomP07ib;
TString chain3Opt = prodP07ib;
chain3Opt += " TpcMixer Embedding onlraw GeantOut MiniMcMk McAna IdTruth -in NoInput,useInTracker EmbeddingShortCut";
if (isSvtIn) chain3Opt += " SvtEmbed";
if (isSsdIn) {
chain1Opt += ",ssddat";
chain2Opt += ",ssd,McEvent,-spt";
chain3Opt += ",SsdEmbed";
}
chain3Opt += " "; chain3Opt += geomP07ib;
// Dynamically link some shared libs
gROOT->LoadMacro("bfc.C");
if (gClassTable->GetID("StBFChain") < 0) Load();
//______________Create the main chain object______________________________________
Chain = new StChain("Embedding");
//________________________________________________________________________________
bfc(-1,chain1Opt,daqfile);
chain1 = chain;
chain1->SetName("One");
Chain->cd();
//________________________________________________________________________________
bfc(-1,chain2Opt);
chain2 = chain;
chain2->SetName("Two");
Chain->cd();
if (chain2->GetOption("TRS")){
StTrsMaker *trsMk = (StTrsMaker *) chain2->GetMaker("Trs");
if (! trsMk) {
cout << "Cannot find Trs in chain2" << endl;
return;
}
trsMk->setNormalFactor(2.67);
}
//________________________________________________________________________________
// gSystem->Load("StFtpcMixerMaker");
// StFtpcMixerMaker *ftpcmixer = new StFtpcMixerMaker("FtpcMixer","daq","trs");
//________________________________________________________________________________
TString OutputFileName(gSystem->BaseName(daqfile));
OutputFileName.ReplaceAll("*","");
OutputFileName.ReplaceAll(".daq","");
// OutputFileName.Append("_emb.root");
OutputFileName.Append(".root");
bfc(-1,chain3Opt,0,OutputFileName);
chain3 = chain;
chain3->SetName("Three");
Chain->cd();
Chain->cd();
//________________________________________________________________________________
{
TDatime t;
gMessMgr->QAInfo() << Form("Run is started at Date/Time %i/%i",t.GetDate(),t.GetTime()) << endm;
}
gMessMgr->QAInfo() << Form("Run on %s in %s",gSystem->HostName(),gSystem->WorkingDirectory()) << endm;
gMessMgr->QAInfo() << Form("with %s", Chain->GetCVS()) << endm;
// embedded particle set
StPrepEmbedMaker *embMk = (StPrepEmbedMaker *) Chain->Maker("PrepEmbed");
if (! embMk) return;
embMk->SetTagFile(tagfile);
// pTlow,ptHigh,etaLow,etaHigh,phiLow,phiHigh
embMk->SetOpt( pt_low, pt_high, eta_low, eta_high, 0., 6.283185);
// pid, mult
embMk->SetPartOpt( pid,mult);
TAttr::SetDebug(0);
Chain->SetAttr(".Privilege",0,"*" ); //All makers are NOT priviliged
Chain->SetAttr(".Privilege",1,"StBFChain::*" ); //StBFChain is priviliged
Chain->SetAttr(".Privilege",1,"StIOInterFace::*" ); //All IO makers are priviliged
Chain->SetAttr(".Privilege",1,"St_geant_Maker::*"); //It is also IO maker
Chain->SetAttr(".Privilege",1,"StPrepEmbedMaker::*"); //It is also IO maker
StMaker *SsdEmbed = Chain->Maker("SsdEmbed");
if (SsdEmbed) {
cout << "SsdEmbed has been found ----------------------------------------" << endl;
SsdEmbed->SetInput("SsdRealData","One/.make/SpaStrip/.data/spa_strip");
SsdEmbed->SetInput("SsdSimuData","Two/.make/SpaStrip/.data/spa_strip");
StMaker *SsdPoint = Chain->Maker("SsdPoint");
if (SsdPoint) {
cout << "SsdPoint has been found----------------------------------------" << endl;
SsdPoint->SetInput("SpaStrip","SsdEmbed");
}
}
// Chain->SetDEBUG(0);
if (Nevents < 0) return;
Int_t iInit = Chain->Init();
if (iInit >= kStEOF) {Chain->FatalErr(iInit,"on init"); return;}
StMaker *treeMk = Chain->GetMaker("outputStream");
Chain->EventLoop(Nevents,treeMk);
gMessMgr->QAInfo() << "Run completed " << endm;
gSystem->Exec("date");
}
// ----------------------------------------------------------------------------
// ----------------------------------------------------------------------------
// ----------------------------------------------------------------------------
void starsim( Int_t nevents=10, Int_t rngSeed=1234 )
{
gROOT->ProcessLine(".L bfc.C");
{
TString simple = "y2012 geant gstar usexgeom agml ";
bfc(0, simple );
}
gSystem->Load( "libVMC.so");
gSystem->Load( "StarGeneratorUtil.so");
gSystem->Load( "StarGeneratorEvent.so");
gSystem->Load( "StarGeneratorBase.so" );
gSystem->Load( "Pythia8_1_62.so");
gSystem->Load( "libMathMore.so" );
// Force loading of xgeometry
gSystem->Load( "xgeometry.so" );
// // And unloading of geometry
// TString geo = gSystem->DynamicPathName("geometry.so");
// if ( !geo.Contains("Error" ) ) {
// std::cout << "Unloading geometry.so" << endl;
// gSystem->Unload( gSystem->DynamicPathName("geometry.so") );
// }
gSystem->Load( "Pythia8_1_62.so" );
// Setup RNG seed and map all ROOT TRandom here
StarRandom::seed( rngSeed );
StarRandom::capture();
//
// Create the primary event generator and insert it
// before the geant maker
//
// StarPrimaryMaker *
primary = new StarPrimaryMaker();
{
primary -> SetFileName( "pythia8.starsim.root");
primary -> SetVertex( 0.1, -0.1, 0.0 );
primary -> SetSigma ( 0.1, 0.1, 30.0 );
chain -> AddBefore( "geant", primary );
}
//
// Setup an event generator
//
Pythia8("pp:W");
//
// Setup cuts on which particles get passed to geant for
// simulation. (To run generator in standalone mode,
// set ptmin=1.0E9.)
// ptmin ptmax
primary->SetPtRange (0.0, -1.0); // GeV
// etamin etamax
primary->SetEtaRange ( -3.0, +3.0 );
// phimin phimax
primary->SetPhiRange ( 0., TMath::TwoPi() );
//
// Setup a realistic z-vertex distribution:
// x = 0 gauss width = 1mm
// y = 0 gauss width = 1mm
// z = 0 gauss width = 30cm
//
primary->SetVertex( 0., 0., 0. );
primary->SetSigma( 0.1, 0.1, 30.0 );
//
// Initialize primary event generator and all sub makers
//
primary -> Init();
//
// Setup geometry and set starsim to use agusread for input
//
//geometry("y2012");
//* AGUSER/GKINE NTRACK ID [ PTLOW PTHIGH YLOW YHIGH PHILOW PHIHIGH ZLOW ZHIGH option ]
command("gkine -4 0");
command("gfile o pythia8.starsim.fzd");
//
// Trigger on nevents
//
trig( nevents );
//
// Finish the chain
//
chain->Finish();
//
// EXIT starsim
//
command("call agexit"); // Make sure that STARSIM exits properly
}
// ______________________________________________
void fzd2bin(const Int_t Nevents=5, const Char_t *fzfile ="muon.fzd",int socketID=9093) {
Int_t i=0;
gSystem->Load("EEmc.so");
gROOT->LoadMacro("bfc.C");
bfc(0,"fzin sim_T gen_T",fzfile);
#ifdef WRITE_SOCKET
cout<<"opening socket="<<socketID<<"\n";
TServerSocket *ss = new TServerSocket(socketID, kTRUE);
cout<<"waits for client1...\n";
// Accept a connection and return a full-duplex communication socket.
TSocket *s0 = ss->Accept();
cout<<"waits 2...\n";
#endif
for (i=1; i<=Nevents; i++ ) {
chain->Clear();
if (chain->Make(i)>=kStEOF) break;
printf("%2d ====================================\n",i);
St_g2t_ctf_hit *emc_hit = (St_g2t_ctf_hit *) chain->FindObject("g2t_eem_hit");
if (emc_hit==0) continue;
#ifdef WRITE_SOCKET// ...... use socket to transport data
cout<<"sending this event via socket ...\n";
// tell the clients to start
EEmcMCData data;
const int mx=1<<14;
char hitBuf[mx];
int nh = data.decode(emc_hit);
cerr << "actual hits " << nh << endl;
int nbw = ev->write(hitBuf,mx);
int ret=s0->SendRaw(hitBuf,nbw);
cout<<ret<<" char sent\n";
if(ret!=nbw) {
cerr<<"socekt Error1 "<<ret<<" "<<nbw<<endl;
}
#endif
#ifdef WRITE_FILE // ...... write events to bin file
static FILE *fd=0;
if(fd==0) {fd=fopen("data.bin","w"); assert(fd);}
EEmcMCData data;
const int mx=1<<14;
char hitBuf[mx];
int nh = data.decode(emc_hit);
cerr << "actual hits " << nh << endl;
int nbw = data->write(hitBuf,mx);
char *cnbw=&nbw;
int j;
for(j=0;j<sizeof(int);j++) fputc(cnbw[j],fd);
for(j=0;j<nbw;j++) fputc(hitBuf[j],fd);
#endif
// .............. do sth with data locally
EEuse1 jan(emc_hit);
jan.work();
}
}
// ----------------------------------------------------------------------------
// ----------------------------------------------------------------------------
// ----------------------------------------------------------------------------
void starsim( Int_t nevents=1, Int_t rngSeed=1234 )
{
gROOT->ProcessLine(".L bfc.C");
{
TString simple = "y2012 geant gstar usexgeom agml ";
bfc(0, simple );
}
gSystem->Load( "libVMC.so");
gSystem->Load( "StarGeneratorUtil.so" );
gSystem->Load( "StarGeneratorEvent.so" );
gSystem->Load( "StarGeneratorBase.so" );
gSystem->Load( "libMathMore.so" );
gSystem->Load( "xgeometry.so" );
// Setup RNG seed and captuire ROOT TRandom
StarRandom::seed(rngSeed);
StarRandom::capture();
//
// Create the primary event generator and insert it
// before the geant maker
//
// StarPrimaryMaker *
_primary = new StarPrimaryMaker();
{
_primary -> SetFileName( "kinematics.starsim.root");
chain -> AddBefore( "geant", _primary );
}
Particles();
Kinematics();
//
// Initialize primary event generator and all sub makers
//
_primary -> Init();
//
// Setup geometry and set starsim to use agusread for input
//
geometry("y2012");
command("gkine -4 0");
command("gfile o pythia6.starsim.fzd");
//
// Setup PT and ETA distributions
//
Double_t pt0 = 3.0;
ptDist = new TF1("ptDist","(x/[0])/(1+(x/[0])^2)^6",0.0,10.0);
ptDist->SetParameter(0, pt0);
ptDist->Draw();
etaDist = new TF1("etaDist","-TMath::Erf(x+2.6)*TMath::Erf(x-2.6)",-0.8,+0.8);
//
// Trigger on nevents
//
trig( nevents );
// command("call agexit"); // Make sure that STARSIM exits properly
}
// ----------------------------------------------------------------------------
// ----------------------------------------------------------------------------
// ----------------------------------------------------------------------------
void starsim( Int_t nevents=50, Int_t rngSeed=1234 )
{
gROOT->ProcessLine(".L bfc.C");
{
TString simple = "y2012 geant gstar usexgeom agml ";
//TString full = "tpcrs TpxRaw y2010a MakeEvent ITTF NoSvtIt NoSsdIt Idst IAna l0 ftpc Sti Tree logger genvtx tpcDB TpcHitMover TpxClu pmd bbcSim tofsim tags emcY2 EEfs evout IdTruth geantout -dstout big fzin MiniMcMk clearmem";
// TString full = "y2012 geant gstar tpcrs genvtx tpcDb tpxclu dedx event sdt20120224 ";
bfc(0, simple );
}
gSystem->Load( "libVMC.so");
gSystem->Load( "StarGeneratorUtil.so" );
gSystem->Load( "StarGeneratorEvent.so" );
gSystem->Load( "StarGeneratorBase.so" );
gSystem->Load( "libMathMore.so" );
gSystem->Load( "libHijing1_383.so");
gSystem->Load( "xgeometry.so" );
// Setup RNG seed and map all ROOT TRandom here
StarRandom::seed( rngSeed );
StarRandom::capture();
//
// Create the primary event generator and insert it
// before the geant maker
//
primary = new StarPrimaryMaker();
{
primary -> SetFileName( "hijing.starsim.root");
chain -> AddBefore( "geant", primary );
}
//
// Setup an event generator
//
Hijing();
//
// Initialize primary event generator and all sub makers
//
primary -> Init();
//
// Setup geometry and set starsim to use agusread for input
//
//geometry("y2012");
command("gkine -4 0");
command("gfile o hijing.starsim.fzd");
//
// Trigger on nevents
//
trig( nevents );
command("gprint kine");
// command("call agexit"); // Make sure that STARSIM exits properly
}
