void
Bchart::
setPosStarts()
{
int i,j,k,l;
for(i = 0 ; i < MAXNUMNTTS ; i++)
for(j = 0 ; j < MAXNUMNTS ; j++) posStarts(i,j) = -1;
int numFor[MAXNUMNTTS];
for(i = 0 ; i < MAXNUMNTTS ; i++) numFor[i] = 0;
FeatureTree* ft = FeatureTree::roots(MCALC);
for(k = 0 ; k < ft->subtree.size() ; k++)
{
FeatureTree* ft2 = ft->subtree.index(k);
i = ft2->ind(); // i = rule term
for(l = 0 ; l < ft2->feats.size() ; l++)
{
Feat* f = ft2->feats.index(l);
j = f->ind(); //j = rule head term;
assert(numFor[j] < MAXNUMNTTS);
//cerr << "For posstart " << j << " headphrase = " << i << endl;
posStarts(j,numFor[j]) = i;
numFor[j]++;
}
}
}
float
logLikely(FeatureTree* ft)
{
//cerr << "LL " << *ft << endl;
int ftc = ft->count;
assert(ftc > 0);
FeatureTree* ftp = parentTree(ft);
assert(ftp);
int ftpc = ftp->count;
assert(ftpc > 0);
FeatMap::iterator fmi = ft->feats.begin();
float ans = 0;
/* we compute the sum for each feature f on ft of
|f|(log(p(f|ft))-log(p(f|ftb))) = logLcomp(fc, ftc, fpc, ftpc) */
for( ; fmi != ft->feats.end() ; fmi++)
{
Feat* f = &((*fmi).second);
Feat* fp = parentFeat(f);
assert(fp);
int fc = f->cnt();
int fpc = fp->cnt();
float val = logLcomp(fc, ftc, fpc, ftpc);
//cerr << "lcomp " << *f << " = " << val << endl;
ans += val;
}
return ans;
}
int initFeats()
{
Feat* dwarf_f = new Feat();
dwarf_f->name = (char*)"Dwarves abilities";
dwarf_f->addTalent(Talent::getTalentByName("Constitution modificator 2"));
dwarf_f->addTalent(Talent::getTalentByName("Wisdom modificator 2"));
dwarf_f->addTalent(Talent::getTalentByName("Charisma modificator -2"));
Feat* elf_f = new Feat();
elf_f->name = (char*)"Elves abilities";
elf_f->addTalent(Talent::getTalentByName("Intelligence modificator 2"));
elf_f->addTalent(Talent::getTalentByName("Dexterity modificator 2"));
elf_f->addTalent(Talent::getTalentByName("Constitution modificator -2"));
Feat* halfelin_f = new Feat();
halfelin_f->name = (char*)"Halfelins abilities";
halfelin_f->addTalent(Talent::getTalentByName("Charisma modificator 2"));
halfelin_f->addTalent(Talent::getTalentByName("Dexterity modificator 2"));
halfelin_f->addTalent(Talent::getTalentByName("Strength modificator -2"));
Feat* gnome_f = new Feat();
gnome_f->name = (char*)"Gnomes abilities";
gnome_f->addTalent(Talent::getTalentByName("Constitution modificator 2"));
gnome_f->addTalent(Talent::getTalentByName("Charisma modificator 2"));
gnome_f->addTalent(Talent::getTalentByName("Strength modificator -2"));
Feat* bonus_f = new Feat();
bonus_f->name = (char*)"Bonus ability";
Feat* keenSenses = new Feat();
keenSenses->name = (char*) "Keen senses";
keenSenses->addTalent(Talent::getTalentByName("Perception modificator 2"));
Feat* intimidating = new Feat();
intimidating->name = (char*)"Intimidating";
intimidating->addTalent(Talent::getTalentByName("Intimidate modificator 2"));
Feat* sureFooted = new Feat();
sureFooted->name = (char*)"Sure-footed";
sureFooted->addTalent(Talent::getTalentByName("Acrobatics modificator 2"));
sureFooted->addTalent(Talent::getTalentByName("Climb modificator 2"));
return 0;
}
void
initFeatVals()
{
FeatIter fi(features);
int m, i;
Feat* f;
for( ; fi.alive() ; fi.next() )
{
f = fi.curr;
int fhij = f->cnt();
assert(fhij > 0);
int hij = f->toTree()->count;
assert(hij > 0);
assert(hij >= fhij);
Feat* fj = parentFeat(f);
int hj, fhj;
if(fj)
{
hj = fj->toTree()->count;
fhj = fj->cnt();
}
else
{
fhj = 1;
hj = 1; // this sets val to fhij/hij;
//hj=FeatureTree::totCaboveMin[whichInt][Feature::assumedFeatVal]+1;
}
assert(hj > 0);
assert(fhj > 0);
assert(hj >= fhj);
//float val = (float)(fhij * hj)/(float)(fhj * hij);
float val = ((float)fhij/(float)hij);
fi.curr->g() = val;
//cerr << *(f->toTree()) << " " << f->ind()
// << " " << val << endl;
if(!(val > 0))
{
cerr << fhij << " " << hj << " " << fhj << " " << hij << endl;
assert(val > 0);
}
}
}
float
Bchart::
meFHProb(const Term* trm, FullHist& fh, int whichInt)
{
Edge* edge = fh.e;
int pos = 0;
/* the left to right position we are working on is either the far left (0)
or the far right */
if(!globalGi) {}
//else if(edge->item() != globalGi->index(0)) ;
else if(whichInt == RUCALC || whichInt == RMCALC || whichInt == RCALC)
pos = globalGi->size()-1;
fh.pos = pos;
int cVal = trm->toInt();
if(printDebug() > 138)
{
cerr << "meP " << *trm << " " << cVal << " " << whichInt << " ";
if(edge) cerr << *edge << endl;
else cerr << fh.preTerm << endl;
}
//int subfVals[MAXNUMFS];
FeatureTree* ginfo[MAXNUMFS];
ginfo[0] = FeatureTree::roots(whichInt);
assert(ginfo[0]);
float smoothedPs[MAXNUMFS];
float ans = 1;
for(int i = 1 ; i <= Feature::total[whichInt] ; i++)
{
ginfo[i] = NULL;
Feature* feat = Feature::fromInt(i, whichInt);
/* e.g., g(rtlu) starts from where g(rtl) left off (after tl)*/
int searchStartInd = feat->startPos;
FeatureTree* strt = ginfo[searchStartInd];
if(!strt)
{
continue;
}
SubFeature* sf = SubFeature::fromInt(feat->subFeat, whichInt);
int usf = sf->usf;
int nfeatV = (edgeFnsArray[usf])(&fh);
FeatureTree* histPt = strt->follow(nfeatV, feat->auxCnt);
ginfo[i] = histPt;
if(i == 1)
{
smoothedPs[0] = 1;
assert(histPt);
Feat* f =histPt->feats.find(cVal);
if(!f)
{
return 0.0;
}
smoothedPs[1] = f->g();
if(printDebug() > 238)
{
cerr << i << " " << nfeatV << " " << smoothedPs[1] << endl;
}
for(int j = 2; j <= Feature::total[whichInt] ; j++)
smoothedPs[j] = 0;
ans = smoothedPs[1];
continue;
}
if(nfeatV < -1)
{
if(printDebug() > 128)
{
cerr<<"p"<<whichInt<< "(" << cVal << "|";
if(edge) cerr << *edge;
else cerr << fh.preTerm;
cerr << ") = " << ans << endl;
}
return ans;
}
if(!histPt)
{
continue;
}
int b;
if(Feature::isLM)
{
/*new bucketing */
float sz = (float)histPt->feats.size();
float estm = (float)histPt->count / sz;
assert(i >= 2);
b = bucket(estm, whichInt,i);
}
else
{
/* old bucketing*/
float estm;
//estm = histPt->count * smoothedPs[1];
estm = histPt->count * 0.1;
b = bucket(estm);
}
Feat* ft = histPt->feats.find(cVal);
float unsmoothedVal;
if(!ft) unsmoothedVal = 0;
else unsmoothedVal = ft->g();
float lam = Feature::getLambda(whichInt, i, b);
float uspathprob = lam*unsmoothedVal;
float osmoothedVal = smoothedPs[searchStartInd];
//float osmoothedVal = smoothedPs[i-1]; //for deleted interp.
float smpathprob = (1-lam)*osmoothedVal;
float nsmoothedVal = uspathprob+smpathprob;
if(printDebug() > 238)
{
cerr << i << " " << nfeatV << " " << usf << " "
<< b <<" "<<unsmoothedVal << " " << lam << " "
<< nsmoothedVal << endl;
}
smoothedPs[i] = nsmoothedVal;
ans *= (nsmoothedVal/osmoothedVal);
}
if(printDebug() > 128)
{
cerr<<"p"<<whichInt<< "(" << cVal << "|";
if(edge) cerr << *edge;
else cerr << fh.preTerm;
cerr << ") = " << ans << endl;
}
return ans;
}
//reduce redistributes, updates 07/02/15 rnc
int main(int argc, char **argv) {
//// Initializations ---------------------------------------------
srand48(1234); // Make sure we have reproducability
check_args(argc);
Time t, time; // t for global, time for local
init_time(t);
Feat F;
MTL M;
// Read parameters file //
F.readInputFile(argv[1]);
printFile(argv[1]);
// Read Secretfile
// Secret contains the identity of each target: QSO-Ly-a, QSO-tracers, LRG, ELG, fake QSO, fake LRG, SS, SF
Gals Secret;
printf("before read secretfile \n");
init_time_at(time,"# read Secret file",t);
Secret=read_Secretfile(F.Secretfile,F);
printf("# Read %d galaxies from %s \n",Secret.size(),F.Secretfile.c_str());
print_time(time,"# ... took :");
std::vector<int> count(10);
count=count_galaxies(Secret);
printf(" Number of galaxies by type, QSO-Ly-a, QSO-tracers, LRG, ELG, fake QSO, fake LRG, SS, SF\n");
for(int i=0;i<8;i++){if(count[i]>0)printf (" type %d number %d \n",i, count[i]);}
//read the three input files
init_time_at(time,"# read target, SS, SF files",t);
MTL Targ=read_MTLfile(F.Targfile,F,0,0);
MTL SStars=read_MTLfile(F.SStarsfile,F,1,0);
MTL SkyF=read_MTLfile(F.SkyFfile,F,0,1);
print_time(time,"# ... took :");
//combine the three input files
M=Targ;
printf(" M size %d \n",M.size());
M.insert(M.end(),SStars.begin(),SStars.end());
printf(" M size %d \n",M.size());
M.insert(M.end(),SkyF.begin(),SkyF.end());
printf(" M size %d \n",M.size());
F.Ngal=M.size();
//establish priority classes
init_time_at(time,"# establish priority clasess",t);
assign_priority_class(M);
std::vector <int> count_class(M.priority_list.size(),0);
for(int i;i<M.size();++i){
if(!M[i].SS&&!M[i].SF){
count_class[M[i].priority_class]+=1;
}
}
for(int i;i<M.priority_list.size();++i){
printf(" class %d number %d\n",i,count_class[i]);
}
print_time(time,"# ... took :");
// fiber positioners
PP pp;
pp.read_fiber_positions(F);
F.Nfiber = pp.fp.size()/2;
F.Npetal = max(pp.spectrom)+1;
F.Nfbp = (int) (F.Nfiber/F.Npetal);// fibers per petal = 500
pp.get_neighbors(F);
pp.compute_fibsofsp(F);
//P is original list of plates
Plates P = read_plate_centers(F);
F.Nplate=P.size();
printf(" full number of plates %d\n",F.Nplate);
printf("# Read %d plates from %s and %d fibers from %s\n",F.Nplate,F.tileFile.c_str(),F.Nfiber,F.fibFile.c_str());
// Computes geometries of cb and fh: pieces of positioner - used to determine possible collisions
F.cb = create_cb(); // cb=central body
F.fh = create_fh(); // fh=fiber holder
//// Collect available galaxies <-> tilefibers --------------------
// HTM Tree of galaxies
const double MinTreeSize = 0.01;
init_time_at(time,"# Start building HTM tree",t);
htmTree<struct target> T(M,MinTreeSize);
print_time(time,"# ... took :");//T.stats();
init_time_at(time,"# collect galaxies at ",t);
// For plates/fibers, collect available galaxies; done in parallel
collect_galaxies_for_all(M,T,P,pp,F);
print_time(time,"# ... took :");//T.stats();
init_time_at(time,"# collect available tile-fibers at",t);
// For each galaxy, computes available tilefibers G[i].av_tfs = [(j1,k1),(j2,k2),..]
collect_available_tilefibers(M,P,F);
//results_on_inputs("doc/figs/",G,P,F,true);
//// Assignment |||||||||||||||||||||||||||||||||||||||||||||||||||
printf(" Nplate %d Ngal %d Nfiber %d \n", F.Nplate, F.Ngal, F.Nfiber);
Assignment A(M,F);
print_time(t,"# Start assignment at : ");
std::cout.flush();
// Make a plan ----------------------------------------------------
// Plans whole survey without sky fibers, standard stars
// assumes maximum number of observations needed for QSOs, LRGs
simple_assign(M,P,pp,F,A);
//check to see if there are tiles with no galaxies
//need to keep mapping of old tile list to new tile list
//and inverse map
A.inv_order=initList(F.Nplate,-1);
int inv_count=0;
for (int j=0;j<F.Nplate ;++j){
bool not_done=true;
for(int k=0;k<F.Nfiber && not_done;++k){
if(A.TF[j][k]!=-1){
A.suborder.push_back(j);//suborder[jused] is jused-th used plate
not_done=false;
A.inv_order[j]=inv_count;//inv_order[j] is -1 unless used
inv_count++;
//and otherwise the position of plate j in list of used plates
}
}
}
F.NUsedplate=A.suborder.size();
printf(" Plates actually used %d \n",F.NUsedplate);
if(F.diagnose)diagnostic(M,Secret,F,A);
print_hist("Unused fibers",5,histogram(A.unused_fbp(pp,F),5),false); // Hist of unused fibs
// Smooth out distribution of free fibers, and increase the number of assignments
for (int i=0; i<1; i++) redistribute_tf(M,P,pp,F,A,0);// more iterations will improve performance slightly
for (int i=0; i<3; i++) {
improve(M,P,pp,F,A,0);
redistribute_tf(M,P,pp,F,A,0);
}
print_hist("Unused fibers",5,histogram(A.unused_fbp(pp,F),5),false);
//try assigning SF and SS before real time assignment
for (int jused=0;jused<F.NUsedplate;++jused){
int j=A.suborder[jused];
assign_sf_ss(j,M,P,pp,F,A); // Assign SS and SF for each tile
assign_unused(j,M,P,pp,F,A);
}
if(F.diagnose)diagnostic(M,Secret,F,A);
init_time_at(time,"# Begin real time assignment",t);
//Execute plan, updating targets at intervals
for(int i=0;i<F.pass_intervals.size();i++){
printf(" i=%d interval %d \n",i,F.pass_intervals[i]);
std::cout.flush();
}
std::vector <int> update_intervals=F.pass_intervals;
update_intervals.push_back(F.NUsedplate);//to end intervals at last plate
for(int i=0;i<update_intervals.size();++i){
printf("i %d update_interval %d\n",i, update_intervals[i]);
}
for(int i=0;i<update_intervals.size()-1;++i){//go plate by used plate
int starter=update_intervals[i];
//printf(" beginning at %d\n",starter);
//std::cout.flush();
for (int jused=starter; jused<update_intervals[i+1]; jused++) {
//printf(" jused %d\n",jused);
//std::cout.flush();
if (0<=jused-F.Analysis) {
update_plan_from_one_obs(jused,Secret,M,P,pp,F,A);
//printf(" 2 jused %d\n",jused);
//std::cout.flush();
}
else printf("\n no update\n");
// Update corrects all future occurrences of wrong QSOs etc and tries to observe something else
}
redistribute_tf(M,P,pp,F,A,starter);
improve(M,P,pp,F,A,starter);
redistribute_tf(M,P,pp,F,A,starter);
if(F.diagnose)diagnostic(M,Secret,F,A);
}
// check on SS and SF
List SS_hist=initList(11,0);
List SF_hist=initList(41,0);
for(int jused=0;jused<F.NUsedplate;++jused){
int j=A.suborder[jused];
for (int p=0;p<F.Npetal;++p){
int count_SS=0;
int count_SF=0;
for (int k=0;k<F.Nfbp;++k){
int kk=pp.fibers_of_sp[p][k];
int g=A.TF[j][kk];
if(g!=-1 && M[g].SS)count_SS++;
if(g!=-1 && M[g].SF)count_SF++;
}
SS_hist[count_SS]++;
SF_hist[count_SF]++;
}
}
printf(" SS distribution \n");
for(int i=0;i<10;i++)printf("%8d",SS_hist[i]);
printf("\n %8d \n",SS_hist[10]);
printf(" SF distribution \n");
for(int i=0;i<10;i++)printf("%8d",SF_hist[i]);
printf("\n");
for(int i=10;i<20;i++)printf("%8d",SF_hist[i]);
printf("\n");
for(int i=20;i<30;i++)printf("%8d",SF_hist[i]);
printf("\n");
for(int i=30;i<40;i++)printf("%8d",SF_hist[i]);
printf("\n %8d \n",SF_hist[40]);
// Results -------------------------------------------------------
if (F.PrintAscii) for (int jused=0; jused<F.NUsedplate; jused++){
write_FAtile_ascii(A.suborder[jused],F.outDir,M,P,pp,F,A);
}
if (F.PrintFits) for (int jused=0; jused<F.NUsedplate; jused++){
fa_write(A.suborder[jused],F.outDir,M,P,pp,F,A); // Write output
}
display_results("doc/figs/",Secret,M,P,pp,F,A,true);
if (F.Verif) A.verif(P,M,pp,F); // Verification that the assignment is sane
print_time(t,"# Finished !... in");
return(0);
}
float
MeChart::
meProb(int cVal, FullHist* h, int whichInt)
{
if(printDebug() > 68)
{
prDp();
cerr << "meP" << whichInt << "(" << cVal << " | " << *h << ")" <<endl;
}
FeatureTree* ginfo[MAXNUMFS];
ginfo[0] = FeatureTree::roots(whichInt);
float smoothedPs[MAXNUMFS];
Feature::whichInt = whichInt;
float ans = 1;
for(int i = 1 ; i <= Feature::total[whichInt] ; i++)
{
int knp = useKn(i,whichInt);
ginfo[i] = NULL;
Feature* feat = Feature::fromInt(i, whichInt);
/* e.g., g(rtlu) starts from where g(rtl) left off (after tl)*/
int searchStartInd = feat->startPos;
if(i > 1) smoothedPs[i] = smoothedPs[i-1];
FeatureTree* strt = ginfo[searchStartInd];
if(!strt)
{
continue;
}
SubFeature* sf = SubFeature::fromInt(feat->subFeat, whichInt);
int nfeatV = (*(sf->fun))(h);
FeatureTree* histPt = strt->follow(nfeatV, feat->auxCnt);
ginfo[i] = histPt;
if(i == 1)
{
smoothedPs[0] = 1;
if(!histPt)
{
cerr << cVal << " " << whichInt << " " << nfeatV << " " << searchStartInd <<" " << feat->auxCnt << endl;
assert(histPt);
}
Feat* f =histPt->feats.find(cVal);
if(!f)
{
if(printDebug() > 60)
{
prDp();
cerr << "Zero p" << feat->name << " " << nfeatV << endl;
}
if(whichInt == HCALC) return 0.001;
return 0.0;
}
smoothedPs[1] = f->g();
if(printDebug() > 68)
{
prDp();
cerr << i << " " << nfeatV << " " << smoothedPs[1] << endl;
}
for(int j = 2; j <= Feature::total[whichInt] ; j++)
smoothedPs[j] = 0;
ans = smoothedPs[1];
continue;
}
if(!histPt)
{
continue;
}
int b;
if(Feature::isLM)
{
/* this section for new bucketing */
float sz = (float)histPt->feats.size();
float estm = (float)histPt->count / sz;
b = bucket(estm, whichInt,i);
}
else
{
/* this section for old bucketing */
float estm = histPt->count * smoothedPs[1];
b = bucket(estm);
}
Feat* ft = histPt->feats.find(cVal);
float unsmoothedVal;
if(!ft) unsmoothedVal = 0;
else unsmoothedVal = ft->g();
float lam = 1;
if(!knp) lam = Feature::getLambda(whichInt, i, b);
float uspathprob = lam*unsmoothedVal;
float osmoothedVal;
/* First version is for parsing, second for language modeling */
if(Feature::isLM)
osmoothedVal = smoothedPs[i-1]; //for deleted interp.
else osmoothedVal = smoothedPs[searchStartInd];
float oneMlam = (1-lam);
if(knp)
{
oneMlam = histPt->count/1000.0;
}
float smpathprob = oneMlam*osmoothedVal;
float nsmoothedVal = uspathprob+smpathprob;
smoothedPs[i] = nsmoothedVal;
ans *= (nsmoothedVal/osmoothedVal);
if(printDebug() > 68)
{
prDp();
cerr << i << " " << nfeatV << " "
<< b <<" "<<unsmoothedVal << " " << lam << " "
<< nsmoothedVal << endl;
}
}
if(whichInt == HCALC) ans *= 600;
if(printDebug() > 30)
{
prDp();
cerr<<"p"<<whichInt<< "(" << cVal << "|" << *h << ") = " << ans << endl;
}
return ans;
}
//reduce redistributes, updates 07/02/15 rnc
int main(int argc, char **argv) {
//// Initializations ---------------------------------------------
srand48(1234); // Make sure we have reproducability
check_args(argc);
Time t, time; // t for global, time for local
init_time(t);
Feat F;
MTL M;
// Read parameters file //
F.readInputFile(argv[1]);
printFile(argv[1]);
init_time_at(time,"# read target, SS, SF files",t);
MTL Targ=read_MTLfile(F.Targfile,F,0,0);
MTL SStars=read_MTLfile(F.SStarsfile,F,1,0);
MTL SkyF=read_MTLfile(F.SkyFfile,F,0,1);
print_time(time,"# ... took :");
//combine the three input files
M=Targ;
printf(" Target size %d \n",M.size());
M.insert(M.end(),SStars.begin(),SStars.end());
printf(" Standard Star size %d \n",M.size());
M.insert(M.end(),SkyF.begin(),SkyF.end());
printf(" Sky Fiber size %d \n",M.size());
F.Ngal = M.size();
assign_priority_class(M);
std::vector <int> count_class(M.priority_list.size(),0);
for(int i;i<M.size();++i){
if(!M[i].SS&&!M[i].SF){
count_class[M[i].priority_class]+=1;
}
}
for(int i;i<M.priority_list.size();++i){
printf(" class %d number %d\n",i,count_class[i]);
}
print_time(time,"# ... took :");
// fiber positioners
PP pp;
pp.read_fiber_positions(F);
F.Nfiber = pp.fp.size()/2;
F.Npetal = max(pp.spectrom)+1;
F.Nfbp = (int) (F.Nfiber/F.Npetal);// fibers per petal = 500
pp.get_neighbors(F);
pp.compute_fibsofsp(F);
//P is original list of plates
Plates P = read_plate_centers(F);
F.Nplate=P.size();
printf("# Read %s plate centers from %s and %d fibers from %s\n",f(F.Nplate).c_str(),F.tileFile.c_str(),F.Nfiber,F.fibFile.c_str());
// Computes geometries of cb and fh: pieces of positioner - used to determine possible collisions
F.cb = create_cb(); // cb=central body
F.fh = create_fh(); // fh=fiber holder
//// Collect available galaxies <-> tilefibers --------------------
// HTM Tree of galaxies
const double MinTreeSize = 0.01;
init_time_at(time,"# Start building HTM tree",t);
htmTree<struct target> T(M,MinTreeSize);
print_time(time,"# ... took :");//T.stats();
init_time_at(time,"# collect galaxies at ",t);
// For plates/fibers, collect available galaxies; done in parallel P[plate j].av_gal[k]=[g1,g2,..]
collect_galaxies_for_all(M,T,P,pp,F);
print_time(time,"# ... took :");//T.stats();
init_time_at(time,"# collect available tile-fibers at",t);
// For each galaxy, computes available tilefibers G[i].av_tfs = [(j1,k1),(j2,k2),..]
collect_available_tilefibers(M,P,F);
//results_on_inputs("doc/figs/",G,P,F,true);
//// Assignment |||||||||||||||||||||||||||||||||||||||||||||||||||
printf(" Nplate %d Ngal %d Nfiber %d \n", F.Nplate, F.Ngal, F.Nfiber);
Assignment A(M,F);
// Make a plan ----------------------------------------------------
print_time(t,"# Start assignment at : ");
simple_assign(M,P,pp,F,A);
//check to see if there are tiles with no galaxies
//need to keep mapping of old tile list to new tile list
//and inverse map
A.inv_order=initList(F.Nplate,-1);
int inv_count=0;
for (int j=0;j<F.Nplate ;++j){
bool not_done=true;
for(int k=0;k<F.Nfiber && not_done;++k){
if(A.TF[j][k]!=-1){
A.suborder.push_back(j);//suborder[jused] is jused-th used plate
not_done=false;
A.inv_order[j]=inv_count;//inv_order[j] is -1 unless used
inv_count++;
}
}
}
F.NUsedplate=A.suborder.size();
printf(" Plates actually used %d \n",F.NUsedplate);
//for(int i=0;i<F.NUsedplate;i++)printf(" jused %d j %d\n",i,A.suborder[i]);
print_hist("Unused fibers",5,histogram(A.unused_fbp(pp,F),5),false); // Hist of unused fibs
// Smooth out distribution of free fibers, and increase the number of assignments
for (int i=0; i<1; i++) redistribute_tf(M,P,pp,F,A,0);// more iterations will improve performance slightly
for (int i=0; i<3; i++) {
improve(M,P,pp,F,A,0);
redistribute_tf(M,P,pp,F,A,0);
}
init_time_at(time,"# assign SS and SF ",t);
print_hist("Unused fibers",5,histogram(A.unused_fbp(pp,F),5),false);
//try assigning SF and SS before real time assignment
for (int jused=0;jused<F.NUsedplate;++jused){
int j=A.suborder[jused];
assign_sf_ss(j,M,P,pp,F,A); // Assign SS and SF for each tile
assign_unused(j,M,P,pp,F,A);
}
// Results -------------------------------------------------------*/
std::vector <int> total_used_by_class(M.priority_list.size(),0);
int total_used_SS=0;
int total_used_SF=0;
for (int jused=0;jused<F.NUsedplate;++jused){
std::vector <int> used_by_class(M.priority_list.size(),0);
int used_SS=0;
int used_SF=0;
int j=A.suborder[jused];
for(int k=0;k<F.Nfiber;++k){
int g=A.TF[j][k];
if(g!=-1){
if(M[g].SS){
total_used_SS++;
used_SS++;
}
else if(M[g].SF){
used_SF++;
total_used_SF++;
}
else{
used_by_class[M[g].priority_class]++;
total_used_by_class[M[g].priority_class]++;
}
}
}
/* printf(" plate jused %5d j %5d SS %4d SF %4d",jused,j,used_SS,used_SF);
for (int pr=0;pr<M.priority_list.size();++pr){
printf(" class %2d %5d",pr,used_by_class[pr]);
}
printf("\n");
*/
}
init_time_at(time,"# count SS and SF ",t);
printf(" Totals SS %4d SF %4d",total_used_SS,total_used_SF);
std::cout.flush();
for (int pr=0;pr<M.priority_list.size();++pr){
printf(" class %2d %5d",pr,total_used_by_class[pr]);
std::cout.flush();
}
printf("\n");
init_time_at(time,"# print txt files ",t);
if (F.PrintAscii) for (int jused=0; jused<F.NUsedplate; jused++){
int j=A.suborder[jused];
write_FAtile_ascii(j,F.outDir,M,P,pp,F,A);
}
init_time_at(time,"# print fits files ",t);
if (F.PrintFits) for (int jused=0; jused<F.NUsedplate; jused++){
int j=A.suborder[jused];
fa_write(j,F.outDir,M,P,pp,F,A); // Write output
}
/*
display_results("doc/figs/",G,M,P,pp,F,A,true);
if (F.Verif) A.verif(P,M,pp,F); // Verification that the assignment is sane
*/
print_time(t,"# Finished !... in");
return(0);
}
int main(int argc, char **argv) {
//// Initializations ---------------------------------------------
srand48(1234); // Make sure we have reproducibility
check_args(argc);
Time t, time; // t for global, time for local
init_time(t);
Feat F;
// Read parameters file //
F.readInputFile(argv[1]);
printFile(argv[1]);
// Read galaxies
MTL M=read_MTLfile(F);
F.Ngal = M.size();
assign_priority_class(M);
//find available SS and SF galaxies on each petal
std::vector <int> count_class(M.priority_list.size(),0);
printf("Number in each priority class. The last two are SF and SS.\n");
for(int i;i<M.size();++i){
count_class[M[i].priority_class]+=1;
}
for(int i;i<M.priority_list.size();++i){
printf(" class %d number %d\n",i,count_class[i]);
}
printf(" number of MTL galaxies %d\n",(int)(M.size()));
PP pp;
pp.read_fiber_positions(F);
F.Nfiber = pp.fp.size()/2;
F.Npetal = max(pp.spectrom)+1;
F.Nfbp = (int) (F.Nfiber/F.Npetal);// fibers per petal = 500
pp.get_neighbors(F); pp.compute_fibsofsp(F);
Plates P = read_plate_centers(F);
F.Nplate=P.size();
printf("# Read %s plate centers from %s and %d fibers from %s\n",f(F.Nplate).c_str(),F.tileFile.c_str(),F.Nfiber,F.fibFile.c_str());
// Computes geometries of cb and fh: pieces of positioner - used to determine possible collisions
F.cb = create_cb(); // cb=central body
F.fh = create_fh(); // fh=fiber holder
//// Collect available galaxies <-> tilefibers --------------------
// HTM Tree of galaxies
const double MinTreeSize = 0.01;
init_time_at(time,"# Start building HTM tree",t);
htmTree<struct target> T(M,MinTreeSize);
print_time(time,"# ... took :");//T.stats();
// For plates/fibers, collect available galaxies; done in parallel P[plate j].av_gal[k]=[g1,g2,..]
collect_galaxies_for_all(M,T,P,pp,F);
// For each galaxy, computes available tilefibers G[i].av_tfs = [(j1,k1),(j2,k2),..]
collect_available_tilefibers(M,P,F);
//// Assignment |||||||||||||||||||||||||||||||||||||||||||||||||||
Assignment A(M,F);
print_time(t,"# Start assignment at : ");
printf(" Nplate %d Ngal %d Nfiber %d \n", F.Nplate, F.Ngal, F.Nfiber);
simple_assign(M,P,pp,F,A);
//diagnostic for skeleton
std::vector<int> countj(F.Nplate,0);
int count_total=0;
for (int j=0;j<F.Nplate;++j){
int nj=0;
for(int k=0;k<F.Nfiber;++k){
if (A.TF[j][k]!=-1){
nj++;
count_total++;
}
}
if(nj>0) printf(" j = %d tileid %d number assigned= %d\n",j, P[j].tileid, nj);
}
printf(" total assigned = %d\n",count_total);
// Results -------------------------------------------------------*/
if (F.PrintFits){
for (int j=0; j<F.Nplate; j++){
fa_write(j,F.outDir,M,P,pp,F,A); // Write output
}
}
print_time(t,"# Finished !... in");
return(0);
}
